Пример #1
0
static GstFlowReturn
gst_mim_enc_chain (GstPad * pad, GstObject * parent, GstBuffer * in)
{
  GstMimEnc *mimenc = GST_MIM_ENC (parent);
  GstBuffer *out = NULL;
  GstMapInfo in_map;
  GstMapInfo out_map;
  GstFlowReturn res = GST_FLOW_OK;
  gboolean keyframe;
  gint buffer_size;

  GST_OBJECT_LOCK (mimenc);


  gst_buffer_map (in, &in_map, GST_MAP_READ);

  out = gst_buffer_new_and_alloc (mimenc->buffer_size + TCP_HEADER_SIZE);
  gst_buffer_map (out, &out_map, GST_MAP_READWRITE);
  GST_BUFFER_TIMESTAMP (out) =
      gst_segment_to_running_time (&mimenc->segment, GST_FORMAT_TIME,
      GST_BUFFER_TIMESTAMP (in));
  mimenc->last_buffer = GST_BUFFER_TIMESTAMP (out);
  buffer_size = mimenc->buffer_size;
  keyframe = (mimenc->frames % MAX_INTERFRAMES) == 0 ? TRUE : FALSE;
  if (!mimic_encode_frame (mimenc->enc, in_map.data,
          out_map.data + TCP_HEADER_SIZE, &buffer_size, keyframe)) {
    gst_buffer_unmap (in, &in_map);
    gst_buffer_unmap (out, &out_map);
    gst_buffer_unref (out);
    GST_ELEMENT_ERROR (mimenc, STREAM, ENCODE, (NULL),
        ("mimic_encode_frame error"));
    res = GST_FLOW_ERROR;
    goto out_unlock;
  }
  gst_buffer_unmap (in, &in_map);

  if (!keyframe)
    GST_BUFFER_FLAG_SET (out, GST_BUFFER_FLAG_DELTA_UNIT);


  GST_LOG_OBJECT (mimenc, "incoming buf size %d, encoded size %d",
      gst_buffer_get_size (in), gst_buffer_get_size (out));
  ++mimenc->frames;

  /* now let's create that tcp header */
  gst_mim_enc_create_tcp_header (mimenc, out_map.data, buffer_size,
      GST_BUFFER_TIMESTAMP (out), keyframe, FALSE);

  gst_buffer_unmap (out, &out_map);
  gst_buffer_resize (out, 0, buffer_size + TCP_HEADER_SIZE);

  GST_OBJECT_UNLOCK (mimenc);

  res = gst_pad_push (mimenc->srcpad, out);

out:
  gst_buffer_unref (in);

  return res;

out_unlock:
  GST_OBJECT_UNLOCK (mimenc);
  goto out;
}
Пример #2
0
static GstFlowReturn
gst_mimenc_chain (GstPad * pad, GstBuffer * in)
{
  GstMimEnc *mimenc;
  GstBuffer *out_buf = NULL, *buf = NULL;
  guchar *data;
  gint buffer_size;
  GstBuffer *header = NULL;
  GstFlowReturn res = GST_FLOW_OK;
  GstEvent *event = NULL;
  gboolean keyframe;

  g_return_val_if_fail (GST_IS_PAD (pad), GST_FLOW_ERROR);
  mimenc = GST_MIMENC (gst_pad_get_parent (pad));

  g_return_val_if_fail (GST_IS_MIMENC (mimenc), GST_FLOW_ERROR);

  GST_OBJECT_LOCK (mimenc);

  if (mimenc->segment.format == GST_FORMAT_UNDEFINED) {
    GST_WARNING_OBJECT (mimenc, "No new-segment received,"
        " initializing segment with time 0..-1");
    gst_segment_init (&mimenc->segment, GST_FORMAT_TIME);
    gst_segment_set_newsegment (&mimenc->segment,
        FALSE, 1.0, GST_FORMAT_TIME, 0, -1, 0);
  }

  if (mimenc->enc == NULL) {
    mimenc->enc = mimic_open ();
    if (mimenc->enc == NULL) {
      GST_WARNING_OBJECT (mimenc, "mimic_open error\n");
      res = GST_FLOW_ERROR;
      goto out_unlock;
    }

    if (!mimic_encoder_init (mimenc->enc, mimenc->res)) {
      GST_WARNING_OBJECT (mimenc, "mimic_encoder_init error\n");
      mimic_close (mimenc->enc);
      mimenc->enc = NULL;
      res = GST_FLOW_ERROR;
      goto out_unlock;
    }

    if (!mimic_get_property (mimenc->enc, "buffer_size", &mimenc->buffer_size)) {
      GST_WARNING_OBJECT (mimenc, "mimic_get_property('buffer_size') error\n");
      mimic_close (mimenc->enc);
      mimenc->enc = NULL;
      res = GST_FLOW_ERROR;
      goto out_unlock;
    }
  }

  buf = in;
  data = GST_BUFFER_DATA (buf);

  out_buf = gst_buffer_new_and_alloc (mimenc->buffer_size);
  GST_BUFFER_TIMESTAMP (out_buf) =
      gst_segment_to_running_time (&mimenc->segment, GST_FORMAT_TIME,
      GST_BUFFER_TIMESTAMP (buf));
  mimenc->last_buffer = GST_BUFFER_TIMESTAMP (out_buf);
  buffer_size = mimenc->buffer_size;
  keyframe = (mimenc->frames % MAX_INTERFRAMES) == 0 ? TRUE : FALSE;
  if (!mimic_encode_frame (mimenc->enc, data, GST_BUFFER_DATA (out_buf),
          &buffer_size, keyframe)) {
    GST_WARNING_OBJECT (mimenc, "mimic_encode_frame error\n");
    gst_buffer_unref (out_buf);
    gst_buffer_unref (buf);
    res = GST_FLOW_ERROR;
    goto out_unlock;
  }
  GST_BUFFER_SIZE (out_buf) = buffer_size;

  GST_DEBUG_OBJECT (mimenc, "incoming buf size %d, encoded size %d",
      GST_BUFFER_SIZE (buf), GST_BUFFER_SIZE (out_buf));
  ++mimenc->frames;

  // now let's create that tcp header
  header = gst_mimenc_create_tcp_header (mimenc, buffer_size,
      GST_BUFFER_TIMESTAMP (out_buf), keyframe, FALSE);

  if (!header) {
    gst_buffer_unref (out_buf);
    GST_DEBUG_OBJECT (mimenc, "header not created succesfully");
    res = GST_FLOW_ERROR;
    goto out_unlock;
  }

  if (mimenc->need_newsegment) {
    event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, 0, -1, 0);
    mimenc->need_newsegment = FALSE;
  }

  GST_OBJECT_UNLOCK (mimenc);

  if (event) {
    if (!gst_pad_push_event (mimenc->srcpad, event))
      GST_WARNING_OBJECT (mimenc, "Failed to push NEWSEGMENT event");
  }

  res = gst_pad_push (mimenc->srcpad, header);
  if (res != GST_FLOW_OK) {
    gst_buffer_unref (out_buf);
    goto out;
  }

  res = gst_pad_push (mimenc->srcpad, out_buf);

out:
  if (buf)
    gst_buffer_unref (buf);
  gst_object_unref (mimenc);

  return res;

out_unlock:
  GST_OBJECT_UNLOCK (mimenc);
  goto out;

}