subprojects/gst-plugins-good/sys/v4l2/gstv4l2videoenc.c

   1 /*
   2  * Copyright (C) 2014-2017 SUMOMO Computer Association
   3  *     Authors Ayaka <ayaka@soulik.info>
   4  * Copyright (C) 2017 Collabora Ltd.
   5  *     Author: Nicolas Dufresne <nicolas.dufresne@collabora.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31 #include <unistd.h>
  32 #include <string.h>
  33
  34 #include "gstv4l2object.h"
  35 #include "gstv4l2videoenc.h"
  36
  37 #include <string.h>
  38 #include <glib/gi18n-lib.h>
  39
  40 GST_DEBUG_CATEGORY_STATIC (gst_v4l2_video_enc_debug);
  41 #define GST_CAT_DEFAULT gst_v4l2_video_enc_debug
  42
  43 typedef struct
  44 {
  45   gchar *device;
  46   GstCaps *sink_caps;
  47   GstCaps *src_caps;
  48   const GstV4l2Codec *codec;
  49 } GstV4l2VideoEncCData;
  50
  51 enum
  52 {
  53   PROP_0,
  54   V4L2_STD_OBJECT_PROPS,
  55 };
  56
  57 #define gst_v4l2_video_enc_parent_class parent_class
  58 G_DEFINE_ABSTRACT_TYPE (GstV4l2VideoEnc, gst_v4l2_video_enc,
  59     GST_TYPE_VIDEO_ENCODER);
  60
  61 static void
  62 gst_v4l2_video_enc_set_property (GObject * object,
  63     guint prop_id, const GValue * value, GParamSpec * pspec)
  64 {
  65   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (object);
  66
  67   switch (prop_id) {
  68     case PROP_CAPTURE_IO_MODE:
  69       if (!gst_v4l2_object_set_property_helper (self->v4l2capture,
  70               prop_id, value, pspec)) {
  71         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  72       }
  73       break;
  74
  75       /* By default, only set on output */
  76     default:
  77       if (!gst_v4l2_object_set_property_helper (self->v4l2output,
  78               prop_id, value, pspec)) {
  79         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  80       }
  81       break;
  82   }
  83 }
  84
  85 static void
  86 gst_v4l2_video_enc_get_property (GObject * object,
  87     guint prop_id, GValue * value, GParamSpec * pspec)
  88 {
  89   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (object);
  90
  91   switch (prop_id) {
  92     case PROP_CAPTURE_IO_MODE:
  93       if (!gst_v4l2_object_get_property_helper (self->v4l2capture,
  94               prop_id, value, pspec)) {
  95         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
  96       }
  97       break;
  98
  99       /* By default read from output */
 100     default:
 101       if (!gst_v4l2_object_get_property_helper (self->v4l2output,
 102               prop_id, value, pspec)) {
 103         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 104       }
 105       break;
 106   }
 107 }
 108
 109 static gboolean
 110 gst_v4l2_video_enc_open (GstVideoEncoder * encoder)
 111 {
 112   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 113   GstV4l2Error error = GST_V4L2_ERROR_INIT;
 114   GstCaps *codec_caps;
 115
 116   GST_DEBUG_OBJECT (self, "Opening");
 117
 118   if (!gst_v4l2_object_open (self->v4l2output, &error))
 119     goto failure;
 120
 121   if (!gst_v4l2_object_open_shared (self->v4l2capture, self->v4l2output))
 122     goto failure;
 123
 124   self->probed_sinkcaps = gst_v4l2_object_probe_caps (self->v4l2output,
 125       gst_v4l2_object_get_raw_caps ());
 126
 127   if (gst_caps_is_empty (self->probed_sinkcaps))
 128     goto no_raw_format;
 129
 130   codec_caps = gst_pad_get_pad_template_caps (encoder->srcpad);
 131   self->probed_srccaps = gst_v4l2_object_probe_caps (self->v4l2capture,
 132       codec_caps);
 133   gst_caps_unref (codec_caps);
 134
 135   if (gst_caps_is_empty (self->probed_srccaps))
 136     goto no_encoded_format;
 137
 138   return TRUE;
 139
 140 no_encoded_format:
 141   GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS,
 142       (_("Encoder on device %s has no supported output format"),
 143           self->v4l2output->videodev), (NULL));
 144   goto failure;
 145
 146
 147 no_raw_format:
 148   GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS,
 149       (_("Encoder on device %s has no supported input format"),
 150           self->v4l2output->videodev), (NULL));
 151   goto failure;
 152
 153 failure:
 154   if (GST_V4L2_IS_OPEN (self->v4l2output))
 155     gst_v4l2_object_close (self->v4l2output);
 156
 157   if (GST_V4L2_IS_OPEN (self->v4l2capture))
 158     gst_v4l2_object_close (self->v4l2capture);
 159
 160   gst_caps_replace (&self->probed_srccaps, NULL);
 161   gst_caps_replace (&self->probed_sinkcaps, NULL);
 162
 163   gst_v4l2_error (self, &error);
 164
 165   return FALSE;
 166 }
 167
 168 static gboolean
 169 gst_v4l2_video_enc_close (GstVideoEncoder * encoder)
 170 {
 171   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 172
 173   GST_DEBUG_OBJECT (self, "Closing");
 174
 175   gst_v4l2_object_close (self->v4l2output);
 176   gst_v4l2_object_close (self->v4l2capture);
 177   gst_caps_replace (&self->probed_srccaps, NULL);
 178   gst_caps_replace (&self->probed_sinkcaps, NULL);
 179
 180   return TRUE;
 181 }
 182
 183 static gboolean
 184 gst_v4l2_video_enc_start (GstVideoEncoder * encoder)
 185 {
 186   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 187
 188   GST_DEBUG_OBJECT (self, "Starting");
 189
 190   gst_v4l2_object_unlock (self->v4l2output);
 191   g_atomic_int_set (&self->active, TRUE);
 192   self->output_flow = GST_FLOW_OK;
 193
 194   return TRUE;
 195 }
 196
 197 static gboolean
 198 gst_v4l2_video_enc_stop (GstVideoEncoder * encoder)
 199 {
 200   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 201
 202   GST_DEBUG_OBJECT (self, "Stopping");
 203
 204   gst_v4l2_object_unlock (self->v4l2output);
 205   gst_v4l2_object_unlock (self->v4l2capture);
 206
 207   /* Wait for capture thread to stop */
 208   gst_pad_stop_task (encoder->srcpad);
 209
 210   GST_VIDEO_ENCODER_STREAM_LOCK (encoder);
 211   self->output_flow = GST_FLOW_OK;
 212   GST_VIDEO_ENCODER_STREAM_UNLOCK (encoder);
 213
 214   /* Should have been flushed already */
 215   g_assert (g_atomic_int_get (&self->active) == FALSE);
 216   g_assert (g_atomic_int_get (&self->processing) == FALSE);
 217
 218   gst_v4l2_object_stop (self->v4l2output);
 219   gst_v4l2_object_stop (self->v4l2capture);
 220
 221   if (self->input_state) {
 222     gst_video_codec_state_unref (self->input_state);
 223     self->input_state = NULL;
 224   }
 225
 226   GST_DEBUG_OBJECT (self, "Stopped");
 227
 228   return TRUE;
 229 }
 230
 231 static gboolean
 232 gst_v4l2_encoder_cmd (GstV4l2Object * v4l2object, guint cmd, guint flags)
 233 {
 234   struct v4l2_encoder_cmd ecmd = { 0, };
 235
 236   GST_DEBUG_OBJECT (v4l2object->element,
 237       "sending v4l2 encoder command %u with flags %u", cmd, flags);
 238
 239   if (!GST_V4L2_IS_OPEN (v4l2object))
 240     return FALSE;
 241
 242   ecmd.cmd = cmd;
 243   ecmd.flags = flags;
 244   if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_ENCODER_CMD, &ecmd) < 0)
 245     goto ecmd_failed;
 246
 247   return TRUE;
 248
 249 ecmd_failed:
 250   if (errno == ENOTTY) {
 251     GST_INFO_OBJECT (v4l2object->element,
 252         "Failed to send encoder command %u with flags %u for '%s'. (%s)",
 253         cmd, flags, v4l2object->videodev, g_strerror (errno));
 254   } else {
 255     GST_ERROR_OBJECT (v4l2object->element,
 256         "Failed to send encoder command %u with flags %u for '%s'. (%s)",
 257         cmd, flags, v4l2object->videodev, g_strerror (errno));
 258   }
 259   return FALSE;
 260 }
 261
 262 static GstFlowReturn
 263 gst_v4l2_video_enc_finish (GstVideoEncoder * encoder)
 264 {
 265   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 266   GstFlowReturn ret = GST_FLOW_OK;
 267
 268   if (gst_pad_get_task_state (encoder->srcpad) != GST_TASK_STARTED)
 269     goto done;
 270
 271   GST_DEBUG_OBJECT (self, "Finishing encoding");
 272
 273   /* drop the stream lock while draining, so remaining buffers can be
 274    * pushed from the src pad task thread */
 275   GST_VIDEO_ENCODER_STREAM_UNLOCK (encoder);
 276
 277   if (gst_v4l2_encoder_cmd (self->v4l2capture, V4L2_ENC_CMD_STOP, 0)) {
 278     GstTask *task = encoder->srcpad->task;
 279
 280     /* Wait for the task to be drained */
 281     GST_DEBUG_OBJECT (self, "Waiting for encoder stop");
 282     GST_OBJECT_LOCK (task);
 283     while (GST_TASK_STATE (task) == GST_TASK_STARTED)
 284       GST_TASK_WAIT (task);
 285     GST_OBJECT_UNLOCK (task);
 286     ret = GST_FLOW_FLUSHING;
 287   }
 288
 289   /* and ensure the processing thread has stopped in case another error
 290    * occurred. */
 291   gst_v4l2_object_unlock (self->v4l2capture);
 292   gst_pad_stop_task (encoder->srcpad);
 293   GST_VIDEO_ENCODER_STREAM_LOCK (encoder);
 294
 295   if (ret == GST_FLOW_FLUSHING)
 296     ret = self->output_flow;
 297
 298   GST_DEBUG_OBJECT (encoder, "Done draining buffers");
 299
 300 done:
 301   return ret;
 302 }
 303
 304 static gboolean
 305 gst_v4l2_video_enc_set_format (GstVideoEncoder * encoder,
 306     GstVideoCodecState * state)
 307 {
 308   gboolean ret = TRUE;
 309   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 310   GstV4l2Error error = GST_V4L2_ERROR_INIT;
 311   GstCaps *outcaps;
 312   GstVideoCodecState *output;
 313
 314   GST_DEBUG_OBJECT (self, "Setting format: %" GST_PTR_FORMAT, state->caps);
 315
 316   if (self->input_state) {
 317     if (gst_v4l2_object_caps_equal (self->v4l2output, state->caps)) {
 318       GST_DEBUG_OBJECT (self, "Compatible caps");
 319       return TRUE;
 320     }
 321
 322     if (gst_v4l2_video_enc_finish (encoder) != GST_FLOW_OK)
 323       return FALSE;
 324
 325     gst_v4l2_object_stop (self->v4l2output);
 326     gst_v4l2_object_stop (self->v4l2capture);
 327
 328     gst_video_codec_state_unref (self->input_state);
 329     self->input_state = NULL;
 330   }
 331
 332   outcaps = gst_pad_get_pad_template_caps (encoder->srcpad);
 333   outcaps = gst_caps_make_writable (outcaps);
 334   output = gst_video_encoder_set_output_state (encoder, outcaps, state);
 335   gst_video_codec_state_unref (output);
 336
 337   if (!gst_video_encoder_negotiate (encoder))
 338     return FALSE;
 339
 340   if (!gst_v4l2_object_set_format (self->v4l2output, state->caps, &error)) {
 341     gst_v4l2_error (self, &error);
 342     return FALSE;
 343   }
 344
 345   /* best effort */
 346   gst_v4l2_object_setup_padding (self->v4l2output);
 347
 348   self->input_state = gst_video_codec_state_ref (state);
 349
 350   GST_DEBUG_OBJECT (self, "output caps: %" GST_PTR_FORMAT, state->caps);
 351
 352   return ret;
 353 }
 354
 355 static gboolean
 356 gst_v4l2_video_enc_flush (GstVideoEncoder * encoder)
 357 {
 358   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 359
 360   GST_DEBUG_OBJECT (self, "Flushing");
 361
 362   /* Ensure the processing thread has stopped for the reverse playback
 363    * iscount case */
 364   if (g_atomic_int_get (&self->processing)) {
 365     GST_VIDEO_ENCODER_STREAM_UNLOCK (encoder);
 366
 367     gst_v4l2_object_unlock_stop (self->v4l2output);
 368     gst_v4l2_object_unlock_stop (self->v4l2capture);
 369     gst_pad_stop_task (encoder->srcpad);
 370
 371     GST_VIDEO_ENCODER_STREAM_UNLOCK (encoder);
 372
 373   }
 374
 375   self->output_flow = GST_FLOW_OK;
 376
 377   gst_v4l2_object_unlock_stop (self->v4l2output);
 378   gst_v4l2_object_unlock_stop (self->v4l2capture);
 379
 380   return TRUE;
 381 }
 382
 383 struct ProfileLevelCtx
 384 {
 385   GstV4l2VideoEnc *self;
 386   const gchar *profile;
 387   const gchar *level;
 388 };
 389
 390 static gboolean
 391 get_string_list (GstStructure * s, const gchar * field, GQueue * queue)
 392 {
 393   const GValue *value;
 394
 395   value = gst_structure_get_value (s, field);
 396
 397   if (!value)
 398     return FALSE;
 399
 400   if (GST_VALUE_HOLDS_LIST (value)) {
 401     guint i;
 402
 403     if (gst_value_list_get_size (value) == 0)
 404       return FALSE;
 405
 406     for (i = 0; i < gst_value_list_get_size (value); i++) {
 407       const GValue *item = gst_value_list_get_value (value, i);
 408
 409       if (G_VALUE_HOLDS_STRING (item))
 410         g_queue_push_tail (queue, g_value_dup_string (item));
 411     }
 412   } else if (G_VALUE_HOLDS_STRING (value)) {
 413     g_queue_push_tail (queue, g_value_dup_string (value));
 414   }
 415
 416   return TRUE;
 417 }
 418
 419 static gboolean
 420 negotiate_profile_and_level (GstCapsFeatures * features, GstStructure * s,
 421     gpointer user_data)
 422 {
 423   struct ProfileLevelCtx *ctx = user_data;
 424   GstV4l2VideoEncClass *klass = GST_V4L2_VIDEO_ENC_GET_CLASS (ctx->self);
 425   GstV4l2Object *v4l2object = GST_V4L2_VIDEO_ENC (ctx->self)->v4l2output;
 426   GQueue profiles = G_QUEUE_INIT;
 427   GQueue levels = G_QUEUE_INIT;
 428   gboolean failed = FALSE;
 429   const GstV4l2Codec *codec = klass->codec;
 430
 431   if (codec->profile_cid && get_string_list (s, "profile", &profiles)) {
 432     GList *l;
 433
 434     for (l = profiles.head; l; l = l->next) {
 435       struct v4l2_control control = { 0, };
 436       gint v4l2_profile;
 437       const gchar *profile = l->data;
 438
 439       GST_TRACE_OBJECT (ctx->self, "Trying profile %s", profile);
 440
 441       control.id = codec->profile_cid;
 442
 443       control.value = v4l2_profile = codec->profile_from_string (profile);
 444
 445       if (control.value < 0)
 446         continue;
 447
 448       if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0) {
 449         GST_WARNING_OBJECT (ctx->self, "Failed to set %s profile: '%s'",
 450             klass->codec_name, g_strerror (errno));
 451         break;
 452       }
 453
 454       profile = codec->profile_to_string (control.value);
 455
 456       if (control.value == v4l2_profile) {
 457         ctx->profile = profile;
 458         break;
 459       }
 460
 461       if (g_list_find_custom (l, profile, g_str_equal)) {
 462         ctx->profile = profile;
 463         break;
 464       }
 465     }
 466
 467     if (profiles.length && !ctx->profile)
 468       failed = TRUE;
 469
 470     g_queue_foreach (&profiles, (GFunc) g_free, NULL);
 471     g_queue_clear (&profiles);
 472   }
 473
 474   if (!failed && codec->level_cid && get_string_list (s, "level", &levels)) {
 475     GList *l;
 476
 477     for (l = levels.head; l; l = l->next) {
 478       struct v4l2_control control = { 0, };
 479       gint v4l2_level;
 480       const gchar *level = l->data;
 481
 482       GST_TRACE_OBJECT (ctx->self, "Trying level %s", level);
 483
 484       control.id = codec->level_cid;
 485       control.value = v4l2_level = codec->level_from_string (level);
 486
 487       if (control.value < 0)
 488         continue;
 489
 490       if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_S_CTRL, &control) < 0) {
 491         GST_WARNING_OBJECT (ctx->self, "Failed to set %s level: '%s'",
 492             klass->codec_name, g_strerror (errno));
 493         break;
 494       }
 495
 496       level = codec->level_to_string (control.value);
 497
 498       if (control.value == v4l2_level) {
 499         ctx->level = level;
 500         break;
 501       }
 502
 503       if (g_list_find_custom (l, level, g_str_equal)) {
 504         ctx->level = level;
 505         break;
 506       }
 507     }
 508
 509     if (levels.length && !ctx->level)
 510       failed = TRUE;
 511
 512     g_queue_foreach (&levels, (GFunc) g_free, NULL);
 513     g_queue_clear (&levels);
 514   }
 515
 516   /* If it failed, we continue */
 517   return failed;
 518 }
 519
 520 static gboolean
 521 gst_v4l2_video_enc_negotiate (GstVideoEncoder * encoder)
 522 {
 523   GstV4l2VideoEncClass *klass = GST_V4L2_VIDEO_ENC_GET_CLASS (encoder);
 524   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 525   GstV4l2Object *v4l2object = self->v4l2output;
 526   GstCaps *allowed_caps;
 527   struct ProfileLevelCtx ctx = { self, NULL, NULL };
 528   GstVideoCodecState *state;
 529   GstStructure *s;
 530   const GstV4l2Codec *codec = klass->codec;
 531
 532   GST_DEBUG_OBJECT (self, "Negotiating %s profile and level.",
 533       klass->codec_name);
 534
 535   /* Only renegotiate on upstream changes */
 536   if (self->input_state)
 537     return TRUE;
 538
 539   if (!codec)
 540     goto done;
 541
 542   allowed_caps = gst_pad_get_allowed_caps (GST_VIDEO_ENCODER_SRC_PAD (encoder));
 543
 544   if (allowed_caps) {
 545
 546     if (gst_caps_is_empty (allowed_caps))
 547       goto not_negotiated;
 548
 549     allowed_caps = gst_caps_make_writable (allowed_caps);
 550
 551     /* negotiate_profile_and_level() will return TRUE on failure to keep
 552      * iterating, if gst_caps_foreach() returns TRUE it means there was no
 553      * compatible profile and level in any of the structure */
 554     if (gst_caps_foreach (allowed_caps, negotiate_profile_and_level, &ctx)) {
 555       goto no_profile_level;
 556     }
 557
 558     gst_caps_unref (allowed_caps);
 559     allowed_caps = NULL;
 560   }
 561
 562   if (codec->profile_cid && !ctx.profile) {
 563     struct v4l2_control control = { 0, };
 564
 565     control.id = codec->profile_cid;
 566
 567     if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)
 568       goto g_ctrl_failed;
 569
 570     ctx.profile = codec->profile_to_string (control.value);
 571   }
 572
 573   if (codec->level_cid && !ctx.level) {
 574     struct v4l2_control control = { 0, };
 575
 576     control.id = codec->level_cid;
 577
 578     if (v4l2object->ioctl (v4l2object->video_fd, VIDIOC_G_CTRL, &control) < 0)
 579       goto g_ctrl_failed;
 580
 581     ctx.level = codec->level_to_string (control.value);
 582   }
 583
 584   GST_DEBUG_OBJECT (self, "Selected %s profile %s at level %s",
 585       klass->codec_name, ctx.profile, ctx.level);
 586
 587   state = gst_video_encoder_get_output_state (encoder);
 588   s = gst_caps_get_structure (state->caps, 0);
 589
 590   if (codec->profile_cid)
 591     gst_structure_set (s, "profile", G_TYPE_STRING, ctx.profile, NULL);
 592
 593   if (codec->level_cid)
 594     gst_structure_set (s, "level", G_TYPE_STRING, ctx.level, NULL);
 595
 596 done:
 597   if (!GST_VIDEO_ENCODER_CLASS (parent_class)->negotiate (encoder))
 598     return FALSE;
 599
 600   return TRUE;
 601
 602 g_ctrl_failed:
 603   GST_WARNING_OBJECT (self, "Failed to get %s profile and level: '%s'",
 604       klass->codec_name, g_strerror (errno));
 605   goto not_negotiated;
 606
 607 no_profile_level:
 608   GST_WARNING_OBJECT (self, "No compatible level and profile in caps: %"
 609       GST_PTR_FORMAT, allowed_caps);
 610   goto not_negotiated;
 611
 612 not_negotiated:
 613   if (allowed_caps)
 614     gst_caps_unref (allowed_caps);
 615   return FALSE;
 616 }
 617
 618 static gboolean
 619 check_system_frame_number_too_old (guint32 current, guint32 old)
 620 {
 621   guint32 absdiff = current > old ? current - old : old - current;
 622
 623   /* More than 100 frames in the past, or current wrapped around */
 624   if (absdiff > 100) {
 625     /* Wraparound and difference is actually smaller than 100 */
 626     if (absdiff > G_MAXUINT32 - 100)
 627       return FALSE;
 628     return TRUE;
 629   }
 630
 631   return FALSE;
 632 }
 633
 634 static void
 635 gst_v4l2_video_enc_loop (GstVideoEncoder * encoder)
 636 {
 637   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 638   GstVideoCodecFrame *frame;
 639   GstBuffer *buffer = NULL;
 640   GstFlowReturn ret;
 641
 642   GST_LOG_OBJECT (encoder, "Allocate output buffer");
 643
 644   buffer = gst_video_encoder_allocate_output_buffer (encoder,
 645       self->v4l2capture->info.size);
 646
 647   if (NULL == buffer) {
 648     ret = GST_FLOW_FLUSHING;
 649     goto beach;
 650   }
 651
 652   /* FIXME Check if buffer isn't the last one here */
 653
 654   GST_LOG_OBJECT (encoder, "Process output buffer");
 655   ret =
 656       gst_v4l2_buffer_pool_process (GST_V4L2_BUFFER_POOL
 657       (self->v4l2capture->pool), &buffer, NULL);
 658
 659   if (ret != GST_FLOW_OK)
 660     goto beach;
 661
 662   if (GST_BUFFER_TIMESTAMP (buffer) % GST_SECOND != 0)
 663     GST_ERROR_OBJECT (encoder,
 664         "Driver bug detected - check driver with v4l2-compliance from http://git.linuxtv.org/v4l-utils.git");
 665   GST_LOG_OBJECT (encoder, "Got buffer for frame number %u",
 666       (guint32) (GST_BUFFER_PTS (buffer) / GST_SECOND));
 667   frame =
 668       gst_video_encoder_get_frame (encoder,
 669       GST_BUFFER_TIMESTAMP (buffer) / GST_SECOND);
 670
 671   if (frame) {
 672     GstVideoCodecFrame *oldest_frame;
 673     gboolean warned = FALSE;
 674
 675     /* Garbage collect old frames in case of codec bugs */
 676     while ((oldest_frame = gst_video_encoder_get_oldest_frame (encoder)) &&
 677         check_system_frame_number_too_old (frame->system_frame_number,
 678             oldest_frame->system_frame_number)) {
 679       gst_video_encoder_finish_frame (encoder, oldest_frame);
 680       oldest_frame = NULL;
 681
 682       if (!warned) {
 683         g_warning ("%s: Too old frames, bug in encoder -- please file a bug",
 684             GST_ELEMENT_NAME (encoder));
 685         warned = TRUE;
 686       }
 687     }
 688     if (oldest_frame)
 689       gst_video_codec_frame_unref (oldest_frame);
 690
 691     /* At this point, the delta unit buffer flag is already correctly set by
 692      * gst_v4l2_buffer_pool_process. Since gst_video_encoder_finish_frame
 693      * will overwrite it from GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame),
 694      * set that here.
 695      */
 696     if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
 697       GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
 698     else
 699       GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
 700     frame->output_buffer = buffer;
 701     buffer = NULL;
 702     ret = gst_video_encoder_finish_frame (encoder, frame);
 703
 704     if (ret != GST_FLOW_OK)
 705       goto beach;
 706   } else {
 707     GST_WARNING_OBJECT (encoder, "Encoder is producing too many buffers");
 708     gst_buffer_unref (buffer);
 709   }
 710
 711   return;
 712
 713 beach:
 714   GST_DEBUG_OBJECT (encoder, "Leaving output thread");
 715
 716   gst_buffer_replace (&buffer, NULL);
 717   self->output_flow = ret;
 718   g_atomic_int_set (&self->processing, FALSE);
 719   gst_v4l2_object_unlock (self->v4l2output);
 720   gst_pad_pause_task (encoder->srcpad);
 721 }
 722
 723 static void
 724 gst_v4l2_video_enc_loop_stopped (GstV4l2VideoEnc * self)
 725 {
 726   if (g_atomic_int_get (&self->processing)) {
 727     GST_DEBUG_OBJECT (self, "Early stop of encoding thread");
 728     self->output_flow = GST_FLOW_FLUSHING;
 729     g_atomic_int_set (&self->processing, FALSE);
 730   }
 731
 732   GST_DEBUG_OBJECT (self, "Encoding task destroyed: %s",
 733       gst_flow_get_name (self->output_flow));
 734
 735 }
 736
 737 static GstFlowReturn
 738 gst_v4l2_video_enc_handle_frame (GstVideoEncoder * encoder,
 739     GstVideoCodecFrame * frame)
 740 {
 741   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 742   GstFlowReturn ret = GST_FLOW_OK;
 743   GstTaskState task_state;
 744
 745   GST_DEBUG_OBJECT (self, "Handling frame %d", frame->system_frame_number);
 746
 747   if (G_UNLIKELY (!g_atomic_int_get (&self->active)))
 748     goto flushing;
 749
 750   task_state = gst_pad_get_task_state (GST_VIDEO_ENCODER_SRC_PAD (self));
 751   if (task_state == GST_TASK_STOPPED || task_state == GST_TASK_PAUSED) {
 752     GstBufferPool *pool = GST_BUFFER_POOL (self->v4l2output->pool);
 753
 754     /* It is possible that the processing thread stopped due to an error or
 755      * when the last buffer has been met during the draining process. */
 756     if (self->output_flow != GST_FLOW_OK &&
 757         self->output_flow != GST_FLOW_FLUSHING &&
 758         self->output_flow != GST_V4L2_FLOW_LAST_BUFFER) {
 759       GST_DEBUG_OBJECT (self, "Processing loop stopped with error: %s, leaving",
 760           gst_flow_get_name (self->output_flow));
 761       ret = self->output_flow;
 762       goto drop;
 763     }
 764
 765     /* Ensure input internal pool is active */
 766     if (!gst_buffer_pool_is_active (pool)) {
 767       GstStructure *config = gst_buffer_pool_get_config (pool);
 768       guint min = MAX (self->v4l2output->min_buffers,
 769           GST_V4L2_MIN_BUFFERS (self->v4l2output));
 770
 771       gst_buffer_pool_config_set_params (config, self->input_state->caps,
 772           self->v4l2output->info.size, min, min);
 773
 774       /* There is no reason to refuse this config */
 775       if (!gst_buffer_pool_set_config (pool, config))
 776         goto activate_failed;
 777
 778       if (!gst_buffer_pool_set_active (pool, TRUE))
 779         goto activate_failed;
 780     }
 781
 782     if (!gst_buffer_pool_set_active
 783         (GST_BUFFER_POOL (self->v4l2capture->pool), TRUE)) {
 784       GST_WARNING_OBJECT (self, "Could not activate capture buffer pool.");
 785       goto activate_failed;
 786     }
 787
 788     GST_DEBUG_OBJECT (self, "Starting encoding thread");
 789
 790     /* Start the processing task, when it quits, the task will disable input
 791      * processing to unlock input if draining, or prevent potential block */
 792     if (!gst_pad_start_task (encoder->srcpad,
 793             (GstTaskFunction) gst_v4l2_video_enc_loop, self,
 794             (GDestroyNotify) gst_v4l2_video_enc_loop_stopped))
 795       goto start_task_failed;
 796   }
 797
 798   if (frame->input_buffer) {
 799     GST_VIDEO_ENCODER_STREAM_UNLOCK (encoder);
 800     GST_LOG_OBJECT (encoder, "Passing buffer with frame number %u",
 801         frame->system_frame_number);
 802     ret =
 803         gst_v4l2_buffer_pool_process (GST_V4L2_BUFFER_POOL (self->
 804             v4l2output->pool), &frame->input_buffer,
 805         &frame->system_frame_number);
 806     GST_VIDEO_ENCODER_STREAM_LOCK (encoder);
 807
 808     if (ret == GST_FLOW_FLUSHING) {
 809       if (gst_pad_get_task_state (encoder->srcpad) != GST_TASK_STARTED)
 810         ret = self->output_flow;
 811       goto drop;
 812     } else if (ret != GST_FLOW_OK) {
 813       goto process_failed;
 814     }
 815   }
 816
 817   gst_video_codec_frame_unref (frame);
 818   return ret;
 819
 820   /* ERRORS */
 821 activate_failed:
 822   {
 823     GST_ELEMENT_ERROR (self, RESOURCE, SETTINGS,
 824         (_("Failed to allocate required memory.")),
 825         ("Buffer pool activation failed"));
 826     return GST_FLOW_ERROR;
 827
 828   }
 829 flushing:
 830   {
 831     ret = GST_FLOW_FLUSHING;
 832     goto drop;
 833   }
 834 start_task_failed:
 835   {
 836     GST_ELEMENT_ERROR (self, RESOURCE, FAILED,
 837         (_("Failed to start encoding thread.")), (NULL));
 838     g_atomic_int_set (&self->processing, FALSE);
 839     ret = GST_FLOW_ERROR;
 840     goto drop;
 841   }
 842 process_failed:
 843   {
 844     GST_ELEMENT_ERROR (self, RESOURCE, FAILED,
 845         (_("Failed to process frame.")),
 846         ("Maybe be due to not enough memory or failing driver"));
 847     ret = GST_FLOW_ERROR;
 848     goto drop;
 849   }
 850 drop:
 851   {
 852     gst_video_encoder_finish_frame (encoder, frame);
 853     return ret;
 854   }
 855 }
 856
 857 static gboolean
 858 gst_v4l2_video_enc_decide_allocation (GstVideoEncoder *
 859     encoder, GstQuery * query)
 860 {
 861   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 862   GstVideoCodecState *state = gst_video_encoder_get_output_state (encoder);
 863   GstCaps *caps;
 864   GstV4l2Error error = GST_V4L2_ERROR_INIT;
 865   GstClockTime latency;
 866   gboolean ret = FALSE;
 867
 868   /* We need to set the format here, since this is called right after
 869    * GstVideoEncoder have set the width, height and framerate into the state
 870    * caps. These are needed by the driver to calculate the buffer size and to
 871    * implement bitrate adaptation. */
 872   caps = gst_caps_copy (state->caps);
 873   gst_structure_remove_field (gst_caps_get_structure (caps, 0), "colorimetry");
 874   if (!gst_v4l2_object_set_format (self->v4l2capture, caps, &error)) {
 875     gst_v4l2_error (self, &error);
 876     gst_caps_unref (caps);
 877     ret = FALSE;
 878     goto done;
 879   }
 880   gst_caps_unref (caps);
 881
 882   /* best effort */
 883   gst_v4l2_object_setup_padding (self->v4l2capture);
 884
 885   if (gst_v4l2_object_decide_allocation (self->v4l2capture, query)) {
 886     GstVideoEncoderClass *enc_class = GST_VIDEO_ENCODER_CLASS (parent_class);
 887     ret = enc_class->decide_allocation (encoder, query);
 888   }
 889
 890   /* FIXME This may not be entirely correct, as encoder may keep some
 891    * observation without delaying the encoding. Linux Media API need some
 892    * more work to explicitly expressed the decoder / encoder latency. This
 893    * value will then become max latency, and the reported driver latency would
 894    * become the min latency. */
 895   if (!GST_CLOCK_TIME_IS_VALID (self->v4l2capture->duration))
 896     self->v4l2capture->duration = gst_util_uint64_scale_int (GST_SECOND, 1, 25);
 897   latency = self->v4l2capture->min_buffers * self->v4l2capture->duration;
 898   gst_video_encoder_set_latency (encoder, latency, latency);
 899   GST_DEBUG_OBJECT (self, "Setting latency: %" GST_TIME_FORMAT,
 900       GST_TIME_ARGS (latency));
 901
 902 done:
 903   gst_video_codec_state_unref (state);
 904   return ret;
 905 }
 906
 907 static gboolean
 908 gst_v4l2_video_enc_propose_allocation (GstVideoEncoder *
 909     encoder, GstQuery * query)
 910 {
 911   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 912   gboolean ret = FALSE;
 913
 914   GST_DEBUG_OBJECT (self, "called");
 915
 916   if (query == NULL)
 917     ret = TRUE;
 918   else
 919     ret = gst_v4l2_object_propose_allocation (self->v4l2output, query);
 920
 921   if (ret)
 922     ret = GST_VIDEO_ENCODER_CLASS (parent_class)->propose_allocation (encoder,
 923         query);
 924
 925   return ret;
 926 }
 927
 928 static gboolean
 929 gst_v4l2_video_enc_src_query (GstVideoEncoder * encoder, GstQuery * query)
 930 {
 931   gboolean ret = TRUE;
 932   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 933   switch (GST_QUERY_TYPE (query)) {
 934     case GST_QUERY_CAPS:{
 935       GstCaps *filter, *result = NULL;
 936       GstPad *pad = GST_VIDEO_ENCODER_SRC_PAD (encoder);
 937
 938       gst_query_parse_caps (query, &filter);
 939
 940       /* FIXME Try and not probe the entire encoder, but only the implement
 941        * subclass format */
 942       if (self->probed_srccaps) {
 943         GstCaps *tmpl = gst_pad_get_pad_template_caps (pad);
 944         result = gst_caps_intersect (tmpl, self->probed_srccaps);
 945         gst_caps_unref (tmpl);
 946       } else
 947         result = gst_pad_get_pad_template_caps (pad);
 948
 949       if (filter) {
 950         GstCaps *tmp = result;
 951         result =
 952             gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
 953         gst_caps_unref (tmp);
 954       }
 955
 956       GST_DEBUG_OBJECT (self, "Returning src caps %" GST_PTR_FORMAT, result);
 957
 958       gst_query_set_caps_result (query, result);
 959       gst_caps_unref (result);
 960       break;
 961     }
 962
 963     default:
 964       ret = GST_VIDEO_ENCODER_CLASS (parent_class)->src_query (encoder, query);
 965       break;
 966   }
 967
 968   return ret;
 969 }
 970
 971 static gboolean
 972 gst_v4l2_video_enc_sink_query (GstVideoEncoder * encoder, GstQuery * query)
 973 {
 974   gboolean ret = TRUE;
 975   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
 976
 977   switch (GST_QUERY_TYPE (query)) {
 978     case GST_QUERY_CAPS:{
 979       GstCaps *filter, *result = NULL;
 980       GstPad *pad = GST_VIDEO_ENCODER_SINK_PAD (encoder);
 981
 982       gst_query_parse_caps (query, &filter);
 983
 984       if (self->probed_sinkcaps)
 985         result = gst_caps_ref (self->probed_sinkcaps);
 986       else
 987         result = gst_pad_get_pad_template_caps (pad);
 988
 989       if (filter) {
 990         GstCaps *tmp = result;
 991         result =
 992             gst_caps_intersect_full (filter, tmp, GST_CAPS_INTERSECT_FIRST);
 993         gst_caps_unref (tmp);
 994       }
 995
 996       GST_DEBUG_OBJECT (self, "Returning sink caps %" GST_PTR_FORMAT, result);
 997
 998       gst_query_set_caps_result (query, result);
 999       gst_caps_unref (result);
1000       break;
1001     }
1002
1003     default:
1004       ret = GST_VIDEO_ENCODER_CLASS (parent_class)->sink_query (encoder, query);
1005       break;
1006   }
1007
1008   return ret;
1009 }
1010
1011 static gboolean
1012 gst_v4l2_video_enc_sink_event (GstVideoEncoder * encoder, GstEvent * event)
1013 {
1014   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (encoder);
1015   gboolean ret;
1016   GstEventType type = GST_EVENT_TYPE (event);
1017
1018   switch (type) {
1019     case GST_EVENT_FLUSH_START:
1020       GST_DEBUG_OBJECT (self, "flush start");
1021       gst_v4l2_object_unlock (self->v4l2output);
1022       gst_v4l2_object_unlock (self->v4l2capture);
1023       break;
1024     default:
1025       break;
1026   }
1027
1028   ret = GST_VIDEO_ENCODER_CLASS (parent_class)->sink_event (encoder, event);
1029
1030   switch (type) {
1031     case GST_EVENT_FLUSH_START:
1032       gst_pad_stop_task (encoder->srcpad);
1033       GST_DEBUG_OBJECT (self, "flush start done");
1034     default:
1035       break;
1036   }
1037
1038   return ret;
1039 }
1040
1041 static GstStateChangeReturn
1042 gst_v4l2_video_enc_change_state (GstElement * element,
1043     GstStateChange transition)
1044 {
1045   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (element);
1046
1047   if (transition == GST_STATE_CHANGE_PAUSED_TO_READY) {
1048     g_atomic_int_set (&self->active, FALSE);
1049     gst_v4l2_object_unlock (self->v4l2output);
1050     gst_v4l2_object_unlock (self->v4l2capture);
1051   }
1052
1053   return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1054 }
1055
1056
1057 static void
1058 gst_v4l2_video_enc_dispose (GObject * object)
1059 {
1060   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (object);
1061
1062   gst_caps_replace (&self->probed_sinkcaps, NULL);
1063   gst_caps_replace (&self->probed_srccaps, NULL);
1064
1065   G_OBJECT_CLASS (parent_class)->dispose (object);
1066 }
1067
1068 static void
1069 gst_v4l2_video_enc_finalize (GObject * object)
1070 {
1071   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (object);
1072
1073   gst_v4l2_object_destroy (self->v4l2capture);
1074   gst_v4l2_object_destroy (self->v4l2output);
1075
1076   G_OBJECT_CLASS (parent_class)->finalize (object);
1077 }
1078
1079
1080 static void
1081 gst_v4l2_video_enc_init (GstV4l2VideoEnc * self)
1082 {
1083   /* V4L2 object are created in subinstance_init */
1084 }
1085
1086 static void
1087 gst_v4l2_video_enc_subinstance_init (GTypeInstance * instance, gpointer g_class)
1088 {
1089   GstV4l2VideoEncClass *klass = GST_V4L2_VIDEO_ENC_CLASS (g_class);
1090   GstV4l2VideoEnc *self = GST_V4L2_VIDEO_ENC (instance);
1091
1092   self->v4l2output = gst_v4l2_object_new (GST_ELEMENT (self),
1093       GST_OBJECT (GST_VIDEO_ENCODER_SINK_PAD (self)),
1094       V4L2_BUF_TYPE_VIDEO_OUTPUT, klass->default_device,
1095       gst_v4l2_get_output, gst_v4l2_set_output, NULL);
1096   self->v4l2output->no_initial_format = TRUE;
1097   self->v4l2output->keep_aspect = FALSE;
1098
1099   self->v4l2capture = gst_v4l2_object_new (GST_ELEMENT (self),
1100       GST_OBJECT (GST_VIDEO_ENCODER_SRC_PAD (self)),
1101       V4L2_BUF_TYPE_VIDEO_CAPTURE, klass->default_device,
1102       gst_v4l2_get_input, gst_v4l2_set_input, NULL);
1103 }
1104
1105 static void
1106 gst_v4l2_video_enc_class_init (GstV4l2VideoEncClass * klass)
1107 {
1108   GstElementClass *element_class;
1109   GObjectClass *gobject_class;
1110   GstVideoEncoderClass *video_encoder_class;
1111
1112   parent_class = g_type_class_peek_parent (klass);
1113
1114   element_class = (GstElementClass *) klass;
1115   gobject_class = (GObjectClass *) klass;
1116   video_encoder_class = (GstVideoEncoderClass *) klass;
1117
1118   GST_DEBUG_CATEGORY_INIT (gst_v4l2_video_enc_debug, "v4l2videoenc", 0,
1119       "V4L2 Video Encoder");
1120
1121   gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_dispose);
1122   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_finalize);
1123   gobject_class->set_property =
1124       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_set_property);
1125   gobject_class->get_property =
1126       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_get_property);
1127
1128   video_encoder_class->open = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_open);
1129   video_encoder_class->close = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_close);
1130   video_encoder_class->start = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_start);
1131   video_encoder_class->stop = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_stop);
1132   video_encoder_class->finish = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_finish);
1133   video_encoder_class->flush = GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_flush);
1134   video_encoder_class->set_format =
1135       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_set_format);
1136   video_encoder_class->negotiate =
1137       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_negotiate);
1138   video_encoder_class->decide_allocation =
1139       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_decide_allocation);
1140   video_encoder_class->propose_allocation =
1141       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_propose_allocation);
1142   video_encoder_class->sink_query =
1143       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_sink_query);
1144   video_encoder_class->src_query =
1145       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_src_query);
1146   video_encoder_class->sink_event =
1147       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_sink_event);
1148   video_encoder_class->handle_frame =
1149       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_handle_frame);
1150
1151   element_class->change_state =
1152       GST_DEBUG_FUNCPTR (gst_v4l2_video_enc_change_state);
1153
1154   gst_v4l2_object_install_m2m_properties_helper (gobject_class);
1155 }
1156
1157 static void
1158 gst_v4l2_video_enc_subclass_init (gpointer g_class, gpointer data)
1159 {
1160   GstV4l2VideoEncClass *klass = GST_V4L2_VIDEO_ENC_CLASS (g_class);
1161   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
1162   GstV4l2VideoEncCData *cdata = data;
1163
1164   klass->default_device = cdata->device;
1165   klass->codec = cdata->codec;
1166
1167   gst_element_class_add_pad_template (element_class,
1168       gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
1169           cdata->sink_caps));
1170   gst_element_class_add_pad_template (element_class,
1171       gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
1172           cdata->src_caps));
1173
1174   gst_caps_unref (cdata->sink_caps);
1175   gst_caps_unref (cdata->src_caps);
1176   g_free (cdata);
1177 }
1178
1179 /* Probing functions */
1180 gboolean
1181 gst_v4l2_is_video_enc (GstCaps * sink_caps, GstCaps * src_caps,
1182     GstCaps * codec_caps)
1183 {
1184   gboolean ret = FALSE;
1185   gboolean (*check_caps) (const GstCaps *, const GstCaps *);
1186
1187   if (codec_caps) {
1188     check_caps = gst_caps_can_intersect;
1189   } else {
1190     codec_caps = gst_v4l2_object_get_codec_caps ();
1191     check_caps = gst_caps_is_subset;
1192   }
1193
1194   if (gst_caps_is_subset (sink_caps, gst_v4l2_object_get_raw_caps ())
1195       && check_caps (src_caps, codec_caps))
1196     ret = TRUE;
1197
1198   return ret;
1199 }
1200
1201 void
1202 gst_v4l2_video_enc_register (GstPlugin * plugin, GType type,
1203     const char *codec_name, const gchar * basename, const gchar * device_path,
1204     const GstV4l2Codec * codec, gint video_fd, GstCaps * sink_caps,
1205     GstCaps * codec_caps, GstCaps * src_caps)
1206 {
1207   GstCaps *filtered_caps;
1208   GTypeQuery type_query;
1209   GTypeInfo type_info = { 0, };
1210   GType subtype;
1211   gchar *type_name;
1212   GstV4l2VideoEncCData *cdata;
1213   GValue value = G_VALUE_INIT;
1214
1215   filtered_caps = gst_caps_intersect (src_caps, codec_caps);
1216
1217   if (codec != NULL && video_fd != -1) {
1218     if (gst_v4l2_codec_probe_levels (codec, video_fd, &value)) {
1219       gst_caps_set_value (filtered_caps, "level", &value);
1220       g_value_unset (&value);
1221     }
1222
1223     if (gst_v4l2_codec_probe_profiles (codec, video_fd, &value)) {
1224       gst_caps_set_value (filtered_caps, "profile", &value);
1225       g_value_unset (&value);
1226     }
1227   }
1228
1229   cdata = g_new0 (GstV4l2VideoEncCData, 1);
1230   cdata->device = g_strdup (device_path);
1231   cdata->sink_caps = gst_caps_ref (sink_caps);
1232   cdata->src_caps = gst_caps_ref (filtered_caps);
1233   cdata->codec = codec;
1234
1235   g_type_query (type, &type_query);
1236   memset (&type_info, 0, sizeof (type_info));
1237   type_info.class_size = type_query.class_size;
1238   type_info.instance_size = type_query.instance_size;
1239   type_info.class_init = gst_v4l2_video_enc_subclass_init;
1240   type_info.class_data = cdata;
1241   type_info.instance_init = gst_v4l2_video_enc_subinstance_init;
1242
1243   /* The first encoder to be registered should use a constant name, like
1244    * v4l2h264enc, for any additional encoders, we create unique names. Encoder
1245    * names may change between boots, so this should help gain stable names for
1246    * the most common use cases. */
1247   type_name = g_strdup_printf ("v4l2%senc", codec_name);
1248
1249   if (g_type_from_name (type_name) != 0) {
1250     g_free (type_name);
1251     type_name = g_strdup_printf ("v4l2%s%senc", basename, codec_name);
1252   }
1253
1254   subtype = g_type_register_static (type, type_name, &type_info, 0);
1255
1256   if (!gst_element_register (plugin, type_name, GST_RANK_PRIMARY + 1, subtype))
1257     GST_WARNING ("Failed to register plugin '%s'", type_name);
1258
1259   g_free (type_name);
1260 }