static void
data_channel_opened_cb (KmsWebRtcDataSessionBin * self, guint stream_id,
gpointer user_data)
{
KmsWebRtcDataChannel *channel;
gboolean is_client;
GstBuffer *buff;
gchar *msg;
g_signal_emit_by_name (self, "get-data-channel", stream_id, &channel);
GST_INFO_OBJECT (channel, "Data channel opened with stream id %u -- %"
GST_PTR_FORMAT, stream_id, self);
g_object_get (self, "dtls-client-mode", &is_client, NULL);
kms_webrtc_data_channel_set_new_buffer_callback (channel,
data_channel_buffer_received_cb, user_data, NULL);
if (!is_client) {
return;
}
msg = g_strdup (TEST_MESSAGE);
buff = gst_buffer_new_wrapped (msg, strlen (msg));
kms_webrtc_data_channel_push_buffer (channel, buff, FALSE);
}
void
cb_need_data (GstElement *appsrc,
guint unused_size,
RendStreamer* rendo)
{
static GstClockTime timestamp = 0;
GstFlowReturn ret;
// printf("cb called \n");;
WorkItem * item=rendo->frame_queue->remove();
GstBuffer *buffer=gst_buffer_new_wrapped (item->buffer,item->bytes);
item->buffer=NULL;
delete item;
GST_BUFFER_PTS (buffer) = timestamp;
GST_BUFFER_DURATION (buffer) = gst_util_uint64_scale_int (1, GST_SECOND, 20);
timestamp += GST_BUFFER_DURATION (buffer);
// printf("pushing the buffer \n");;
g_signal_emit_by_name (appsrc, "push-buffer", buffer, &ret);
// printf("pushed the buffer \n");;
gst_buffer_unref(buffer);
if (ret != GST_FLOW_OK) {
/* something wrong, stop pushing */
g_main_loop_quit (rendo->loop);
}
}
static gboolean
new_packet_cb (guint8 * data, guint len, void *user_data)
{
/* Called when the PsMux has prepared a packet for output. Return FALSE
* on error */
MpegPsMux *mux = (MpegPsMux *) user_data;
GstBuffer *buf;
GstFlowReturn ret;
GST_LOG_OBJECT (mux, "Outputting a packet of length %d", len);
data = g_memdup (data, len);
buf = gst_buffer_new_wrapped (data, len);
GST_BUFFER_TIMESTAMP (buf) = mux->last_ts;
if (mux->aggregate_gops) {
if (mux->gop_list == NULL)
mux->gop_list = gst_buffer_list_new ();
gst_buffer_list_add (mux->gop_list, buf);
return TRUE;
}
ret = gst_pad_push (mux->srcpad, buf);
if (G_UNLIKELY (ret != GST_FLOW_OK)) {
mux->last_flow_ret = ret;
return FALSE;
}
return TRUE;
}
static void
on_key_received (GstDtlsConnection * connection, gpointer key, guint cipher,
guint auth, GstDtlsDec * self)
{
gpointer key_dup;
gchar *key_str;
g_return_if_fail (GST_IS_DTLS_DEC (self));
self->srtp_cipher = cipher;
self->srtp_auth = auth;
key_dup = g_memdup (key, GST_DTLS_SRTP_MASTER_KEY_LENGTH);
if (self->decoder_key) {
gst_buffer_unref (self->decoder_key);
self->decoder_key = NULL;
}
self->decoder_key =
gst_buffer_new_wrapped (key_dup, GST_DTLS_SRTP_MASTER_KEY_LENGTH);
key_str = g_base64_encode (key, GST_DTLS_SRTP_MASTER_KEY_LENGTH);
GST_INFO_OBJECT (self, "received key: %s", key_str);
g_free (key_str);
g_signal_emit (self, signals[SIGNAL_ON_KEY_RECEIVED], 0);
}
GstBuffer *
flv_generate_header ()
{
guint8 *data = g_malloc (sizeof (flv_header));
memcpy (data, flv_header, sizeof (flv_header));
return gst_buffer_new_wrapped (data, sizeof (flv_header));
}
static GstFlowReturn
gst_audio_encoder_tester_handle_frame (GstAudioEncoder * enc,
GstBuffer * buffer)
{
guint8 *data;
GstMapInfo map;
guint64 input_num;
GstBuffer *output_buffer;
if (buffer == NULL)
return GST_FLOW_OK;
gst_buffer_map (buffer, &map, GST_MAP_READ);
input_num = *((guint64 *) map.data);
gst_buffer_unmap (buffer, &map);
data = g_malloc (sizeof (guint64));
*(guint64 *) data = input_num;
output_buffer = gst_buffer_new_wrapped (data, sizeof (guint64));
GST_BUFFER_PTS (output_buffer) = GST_BUFFER_PTS (buffer);
GST_BUFFER_DURATION (output_buffer) = GST_BUFFER_DURATION (buffer);
return gst_audio_encoder_finish_frame (enc, output_buffer, TEST_AUDIO_RATE);
}
static GstFlowReturn
gst_speex_enc_handle_frame (GstAudioEncoder * benc, GstBuffer * buf)
{
GstSpeexEnc *enc;
GstFlowReturn ret = GST_FLOW_OK;
enc = GST_SPEEX_ENC (benc);
if (!enc->header_sent) {
/* Speex streams begin with two headers; the initial header (with
most of the codec setup parameters) which is mandated by the Ogg
bitstream spec. The second header holds any comment fields.
We merely need to make the headers, then pass them to libspeex
one at a time; libspeex handles the additional Ogg bitstream
constraints */
GstBuffer *buf1, *buf2;
GstCaps *caps;
guchar *data;
gint data_len;
GList *headers;
/* create header buffer */
data = (guint8 *) speex_header_to_packet (&enc->header, &data_len);
buf1 = gst_buffer_new_wrapped (data, data_len);
GST_BUFFER_OFFSET_END (buf1) = 0;
GST_BUFFER_OFFSET (buf1) = 0;
/* create comment buffer */
buf2 = gst_speex_enc_create_metadata_buffer (enc);
/* mark and put on caps */
caps = gst_caps_new_simple ("audio/x-speex", "rate", G_TYPE_INT, enc->rate,
"channels", G_TYPE_INT, enc->channels, NULL);
caps = _gst_caps_set_buffer_array (caps, "streamheader", buf1, buf2, NULL);
/* negotiate with these caps */
GST_DEBUG_OBJECT (enc, "here are the caps: %" GST_PTR_FORMAT, caps);
gst_audio_encoder_set_output_format (GST_AUDIO_ENCODER (enc), caps);
gst_caps_unref (caps);
/* push out buffers */
/* store buffers for later pre_push sending */
headers = NULL;
GST_DEBUG_OBJECT (enc, "storing header buffers");
headers = g_list_prepend (headers, buf2);
headers = g_list_prepend (headers, buf1);
gst_audio_encoder_set_headers (benc, headers);
enc->header_sent = TRUE;
}
GST_DEBUG_OBJECT (enc, "received buffer %p of %" G_GSIZE_FORMAT " bytes", buf,
buf ? gst_buffer_get_size (buf) : 0);
ret = gst_speex_enc_encode (enc, buf);
return ret;
}
/**
* gst_adapter_take_buffer:
* @adapter: a #GstAdapter
* @nbytes: the number of bytes to take
*
* Returns a #GstBuffer containing the first @nbytes bytes of the
* @adapter. The returned bytes will be flushed from the adapter.
* This function is potentially more performant than gst_adapter_take()
* since it can reuse the memory in pushed buffers by subbuffering
* or merging.
*
* Note that no assumptions should be made as to whether certain buffer
* flags such as the DISCONT flag are set on the returned buffer, or not.
* The caller needs to explicitly set or unset flags that should be set or
* unset.
*
* Caller owns a reference to the returned buffer. gst_buffer_unref() after
* usage.
*
* Free-function: gst_buffer_unref
*
* Returns: (transfer full): a #GstBuffer containing the first @nbytes of
* the adapter, or #NULL if @nbytes bytes are not available.
* gst_buffer_unref() when no longer needed.
*/
GstBuffer *
gst_adapter_take_buffer (GstAdapter * adapter, gsize nbytes)
{
GstBuffer *buffer;
GstBuffer *cur;
gsize hsize, skip;
guint8 *data;
g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);
g_return_val_if_fail (nbytes > 0, NULL);
GST_LOG_OBJECT (adapter, "taking buffer of %" G_GSIZE_FORMAT " bytes",
nbytes);
/* we don't have enough data, return NULL. This is unlikely
* as one usually does an _available() first instead of grabbing a
* random size. */
if (G_UNLIKELY (nbytes > adapter->size))
return NULL;
cur = adapter->buflist->data;
skip = adapter->skip;
hsize = gst_buffer_get_size (cur);
/* our head buffer has enough data left, return it */
if (skip == 0 && hsize == nbytes) {
GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
" as head buffer", nbytes);
buffer = gst_buffer_ref (cur);
goto done;
} else if (hsize >= nbytes + skip) {
GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
" via region copy", nbytes);
buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, nbytes);
goto done;
}
#if 0
if (gst_adapter_try_to_merge_up (adapter, nbytes)) {
/* Merged something, let's try again for sub-buffering */
cur = adapter->buflist->data;
skip = adapter->skip;
if (gst_buffer_get_size (cur) >= nbytes + skip) {
GST_LOG_OBJECT (adapter, "providing buffer of %" G_GSIZE_FORMAT " bytes"
" via sub-buffer", nbytes);
buffer = gst_buffer_copy_region (cur, GST_BUFFER_COPY_ALL, skip, nbytes);
goto done;
}
}
#endif
data = gst_adapter_take_internal (adapter, nbytes);
buffer = gst_buffer_new_wrapped (data, nbytes);
done:
gst_adapter_flush_unchecked (adapter, nbytes);
return buffer;
}
static gboolean
gst_vtenc_negotiate_downstream (GstVTEnc * self, CMSampleBufferRef sbuf)
{
gboolean result;
GstCaps *caps;
GstStructure *s;
if (self->caps_width == self->negotiated_width &&
self->caps_height == self->negotiated_height &&
self->caps_fps_n == self->negotiated_fps_n &&
self->caps_fps_d == self->negotiated_fps_d) {
return TRUE;
}
caps = gst_pad_get_pad_template_caps (self->srcpad);
caps = gst_caps_make_writable (caps);
s = gst_caps_get_structure (caps, 0);
gst_structure_set (s,
"width", G_TYPE_INT, self->negotiated_width,
"height", G_TYPE_INT, self->negotiated_height,
"framerate", GST_TYPE_FRACTION,
self->negotiated_fps_n, self->negotiated_fps_d, NULL);
if (self->details->format_id == kVTFormatH264) {
CMFormatDescriptionRef fmt;
CFDictionaryRef atoms;
CFStringRef avccKey;
CFDataRef avcc;
gpointer codec_data;
gsize codec_data_size;
GstBuffer *codec_data_buf;
fmt = CMSampleBufferGetFormatDescription (sbuf);
atoms = CMFormatDescriptionGetExtension (fmt,
kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms);
avccKey = CFStringCreateWithCString (NULL, "avcC", kCFStringEncodingUTF8);
avcc = CFDictionaryGetValue (atoms, avccKey);
CFRelease (avccKey);
codec_data_size = CFDataGetLength (avcc);
codec_data = g_malloc (codec_data_size);
CFDataGetBytes (avcc, CFRangeMake (0, codec_data_size), codec_data);
codec_data_buf = gst_buffer_new_wrapped (codec_data, codec_data_size);
gst_structure_set (s, "codec_data", GST_TYPE_BUFFER, codec_data_buf, NULL);
gst_buffer_unref (codec_data_buf);
}
result = gst_pad_push_event (self->srcpad, gst_event_new_caps (caps));
gst_caps_unref (caps);
self->caps_width = self->negotiated_width;
self->caps_height = self->negotiated_height;
self->caps_fps_n = self->negotiated_fps_n;
self->caps_fps_d = self->negotiated_fps_d;
return result;
}
static GstBuffer *
gst_dtmf_src_generate_silence (float duration, gint sample_rate)
{
gint buf_size;
/* Create a buffer with data set to 0 */
buf_size = ((duration / 1000) * sample_rate * SAMPLE_SIZE * CHANNELS) / 8;
return gst_buffer_new_wrapped (g_malloc0 (buf_size), buf_size);
}
static GstFlowReturn
gst_mms_create (GstPushSrc * psrc, GstBuffer ** buf)
{
GstMMS *mmssrc = GST_MMS (psrc);
guint8 *data;
guint blocksize;
gint result;
mms_off_t offset;
*buf = NULL;
offset = mmsx_get_current_pos (mmssrc->connection);
/* Check if a seek perhaps has wrecked our connection */
if (offset == -1) {
GST_ERROR_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);
data = g_try_malloc (blocksize);
if (!data) {
GST_ERROR_OBJECT (mmssrc, "Failed to allocate %u bytes", blocksize);
return GST_FLOW_ERROR;
}
GST_LOG_OBJECT (mmssrc, "reading %d bytes", blocksize);
result = mmsx_read (NULL, mmssrc->connection, (char *) data, blocksize);
/* EOS? */
if (result == 0)
goto eos;
*buf = gst_buffer_new_wrapped (data, result);
GST_BUFFER_OFFSET (*buf) = offset;
GST_LOG_OBJECT (mmssrc, "Returning buffer with offset %" G_GINT64_FORMAT
" and size %u", offset, result);
return GST_FLOW_OK;
eos:
{
GST_DEBUG_OBJECT (mmssrc, "EOS");
g_free (data);
*buf = NULL;
return GST_FLOW_EOS;
}
}
extern int
feed_buffer_to_gst (const char *audio, size_t b_len, GNUNET_gstData * d)
{
GstBuffer *b;
gchar *bufspace;
GstFlowReturn flow;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Feeding %u bytes to GStreamer\n",
(unsigned int) b_len);
bufspace = g_memdup (audio, b_len);
b = gst_buffer_new_wrapped (bufspace, b_len);
if (NULL == b)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to wrap a buffer\n");
g_free (bufspace);
return GNUNET_SYSERR;
}
if (GST_APP_SRC(d->appsrc) == NULL)
exit(10);
flow = gst_app_src_push_buffer (GST_APP_SRC(d->appsrc), b);
/* They all return GNUNET_OK, because currently player stops when
* data stops coming. This might need to be changed for the player
* to also stop when pipeline breaks.
*/
switch (flow)
{
case GST_FLOW_OK:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Fed %u bytes to the pipeline\n",
(unsigned int) b_len);
break;
case GST_FLOW_FLUSHING:
/* buffer was dropped, because pipeline state is not PAUSED or PLAYING */
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Dropped a buffer\n");
break;
case GST_FLOW_EOS:
/* end of stream */
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"EOS\n");
break;
default:
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Unexpected push result\n");
break;
}
return GNUNET_OK;
}
static GstFlowReturn
gst_srt_enc_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
{
GstSrtEnc *srtenc = GST_SRT_ENC (parent);
GstClockTime ts, dur = GST_SECOND;
GstBuffer *new_buffer;
GstMapInfo map_info;
GString *s;
gsize buf_size;
gst_object_sync_values (GST_OBJECT (srtenc), GST_BUFFER_PTS (buf));
ts = GST_BUFFER_PTS (buf) + srtenc->timestamp;
if (GST_BUFFER_DURATION_IS_VALID (buf))
dur = GST_BUFFER_DURATION (buf) + srtenc->duration;
else if (srtenc->duration > 0)
dur = srtenc->duration;
else
dur = GST_SECOND;
buf_size = gst_buffer_get_size (buf);
s = g_string_sized_new (10 + 50 + buf_size + 2 + 1);
/* stanza count */
g_string_append_printf (s, "%d\n", srtenc->counter++);
/* start_time --> end_time */
gst_srt_enc_append_timestamp_to_string (ts, s);
g_string_append_printf (s, " --> ");
gst_srt_enc_append_timestamp_to_string (ts + dur, s);
g_string_append_c (s, '\n');
/* text */
if (gst_buffer_map (buf, &map_info, GST_MAP_READ)) {
g_string_append_len (s, (const gchar *) map_info.data, map_info.size);
gst_buffer_unmap (buf, &map_info);
}
g_string_append (s, "\n\n");
buf_size = s->len;
new_buffer = gst_buffer_new_wrapped (g_string_free (s, FALSE), buf_size);
GST_BUFFER_TIMESTAMP (new_buffer) = GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_DURATION (new_buffer) = GST_BUFFER_DURATION (buf);
gst_buffer_unref (buf);
return gst_pad_push (srtenc->srcpad, new_buffer);
}
static GstBuffer *
_buffer_from_file (const gchar * filename)
{
GstBuffer *buffer;
gchar *contents = NULL;
gsize length = 0;
fail_unless (g_file_get_contents (filename, &contents, &length, NULL));
buffer = gst_buffer_new_wrapped (contents, length);
GST_BUFFER_OFFSET (buffer) = 0;
return buffer;
}
static void
gst_cenc_decrypt_parse_pssh_box (GstCencDecrypt * self, GstBuffer * pssh)
{
GstMapInfo info;
GstByteReader br;
guint8 version;
guint32 data_size;
gst_buffer_map (pssh, &info, GST_MAP_READ);
gst_byte_reader_init (&br, info.data, info.size);
gst_byte_reader_skip_unchecked (&br, 8);
version = gst_byte_reader_get_uint8_unchecked (&br);
GST_DEBUG_OBJECT (self, "pssh version: %u", version);
gst_byte_reader_skip_unchecked (&br, 19);
if (version > 0) {
/* Parse KeyIDs */
guint32 key_id_count = 0;
const guint8 *key_id_data = NULL;
const guint key_id_size = 16;
key_id_count = gst_byte_reader_get_uint32_be_unchecked (&br);
GST_DEBUG_OBJECT (self, "there are %u key IDs", key_id_count);
key_id_data = gst_byte_reader_get_data_unchecked (&br, key_id_count * 16);
while (key_id_count > 0) {
gchar *key_id_string = gst_cenc_create_uuid_string (key_id_data);
GST_DEBUG_OBJECT (self, "key_id: %s", key_id_string);
g_free (key_id_string);
key_id_data += key_id_size;
--key_id_count;
}
}
/* Parse Data */
data_size = gst_byte_reader_get_uint32_be_unchecked (&br);
GST_DEBUG_OBJECT (self, "pssh data size: %u", data_size);
if (data_size > 0U) {
gpointer data =
g_memdup (gst_byte_reader_get_data_unchecked (&br, data_size),
data_size);
GstBuffer *buf = gst_buffer_new_wrapped (data, data_size);
GST_DEBUG_OBJECT (self, "cenc protection system data size: %"
G_GSIZE_FORMAT, gst_buffer_get_size (buf));
gst_buffer_unref (buf);
}
gst_buffer_unmap (pssh, &info);
}
static gboolean
read_response (GstFestival * festival)
{
char ack[4];
char *data;
int filesize;
int fd;
int n;
gboolean ret = TRUE;
fd = festival->info->server_fd;
do {
for (n = 0; n < 3;)
n += read (fd, ack + n, 3 - n);
ack[3] = '\0';
GST_DEBUG_OBJECT (festival, "got response %s", ack);
if (strcmp (ack, "WV\n") == 0) {
GstBuffer *buffer;
/* receive a waveform */
data = socket_receive_file_to_buff (fd, &filesize);
GST_DEBUG_OBJECT (festival, "received %d bytes of waveform data",
filesize);
/* push contents as a buffer */
buffer = gst_buffer_new_wrapped (data, filesize);
GST_BUFFER_TIMESTAMP (buffer) = GST_CLOCK_TIME_NONE;
gst_pad_push (festival->srcpad, buffer);
} else if (strcmp (ack, "LP\n") == 0) {
/* receive an s-expr */
data = client_accept_s_expr (fd);
GST_DEBUG_OBJECT (festival, "received s-expression: %s", data);
g_free (data);
} else if (strcmp (ack, "ER\n") == 0) {
/* server got an error */
GST_ELEMENT_ERROR (festival,
LIBRARY,
FAILED,
("Festival speech server returned an error"),
("Make sure you have voices/languages installed"));
ret = FALSE;
break;
}
} while (strcmp (ack, "OK\n") != 0);
return ret;
}
GstBuffer *
flv_generate_tag (const guint8 * data, gsize size, guint8 id, guint32 timestamp)
{
guint size_with_header = size + flv_tag_header_size;
guint tag_size = size_with_header + 4;
guint8 *tag = g_malloc (tag_size);
flv_write_tag (tag, id, size, timestamp);
memcpy (&tag[flv_tag_header_size], data, size);
/* write the total length (size_with_header) in the last 4 bytes */
GST_WRITE_UINT32_BE (&tag[size_with_header], size_with_header);
return gst_buffer_new_wrapped (tag, tag_size);
}
static FrameNode *
deserialize_framenode (const gchar ** names, const gchar ** values)
{
gint i;
FrameNode *framenode = g_slice_new0 (FrameNode);
for (i = 0; names[i] != NULL; i++) {
if (g_strcmp0 (names[i], "id") == 0)
framenode->id = g_ascii_strtoull (values[i], NULL, 0);
else if (g_strcmp0 (names[i], "offset") == 0)
framenode->offset = g_ascii_strtoull (values[i], NULL, 0);
else if (g_strcmp0 (names[i], "offset-end") == 0)
framenode->offset_end = g_ascii_strtoull (values[i], NULL, 0);
else if (g_strcmp0 (names[i], "duration") == 0)
framenode->duration = g_ascii_strtoull (values[i], NULL, 0);
else if (g_strcmp0 (names[i], "pts") == 0)
framenode->pts = g_ascii_strtoull (values[i], NULL, 0);
else if (g_strcmp0 (names[i], "dts") == 0)
framenode->dts = g_ascii_strtoull (values[i], NULL, 0);
else if (g_strcmp0 (names[i], "checksum") == 0)
framenode->checksum = g_strdup (values[i]);
else if (g_strcmp0 (names[i], "is-keyframe") == 0) {
if (!g_ascii_strcasecmp (values[i], "true"))
framenode->is_keyframe = TRUE;
else
framenode->is_keyframe = FALSE;
}
}
framenode->buf = gst_buffer_new_wrapped (framenode->checksum,
strlen (framenode->checksum) + 1);
GST_BUFFER_OFFSET (framenode->buf) = framenode->offset;
GST_BUFFER_OFFSET_END (framenode->buf) = framenode->offset_end;
GST_BUFFER_DURATION (framenode->buf) = framenode->duration;
GST_BUFFER_PTS (framenode->buf) = framenode->pts;
GST_BUFFER_DTS (framenode->buf) = framenode->dts;
if (framenode->is_keyframe) {
GST_BUFFER_FLAG_UNSET (framenode->buf, GST_BUFFER_FLAG_DELTA_UNIT);
} else {
GST_BUFFER_FLAG_SET (framenode->buf, GST_BUFFER_FLAG_DELTA_UNIT);
}
return framenode;
}
static GstBuffer *
create_test_buffer (guint64 num)
{
GstBuffer *buffer;
guint64 *data = g_malloc (sizeof (guint64));
*data = num;
buffer = gst_buffer_new_wrapped (data, sizeof (guint64));
GST_BUFFER_PTS (buffer) =
gst_util_uint64_scale_round (num, GST_SECOND, TEST_MSECS_PER_SAMPLE);
GST_BUFFER_DURATION (buffer) =
gst_util_uint64_scale_round (1, GST_SECOND, TEST_MSECS_PER_SAMPLE);
return buffer;
}
static GstFlowReturn
gst_audio_decoder_tester_handle_frame (GstAudioDecoder * dec,
GstBuffer * buffer)
{
GstAudioDecoderTester *tester = (GstAudioDecoderTester *) dec;
guint8 *data;
gint size;
GstMapInfo map;
GstBuffer *output_buffer;
if (buffer == NULL)
return GST_FLOW_OK;
if (tester->setoutputformat_on_decoding) {
GstCaps *caps;
GstAudioInfo info;
caps = gst_caps_new_simple ("audio/x-raw", "format", G_TYPE_STRING, "S32LE",
"channels", G_TYPE_INT, 2, "rate", G_TYPE_INT, 44100,
"layout", G_TYPE_STRING, "interleaved", NULL);
gst_audio_info_from_caps (&info, caps);
gst_caps_unref (caps);
gst_audio_decoder_set_output_format (dec, &info);
}
gst_buffer_map (buffer, &map, GST_MAP_READ);
/* the output is SE32LE stereo 44100 Hz */
size = 2 * 4;
g_assert (size == sizeof (guint64));
data = g_malloc0 (size);
memcpy (data, map.data, sizeof (guint64));
output_buffer = gst_buffer_new_wrapped (data, size);
gst_buffer_unmap (buffer, &map);
if (tester->output_too_many_frames) {
return gst_audio_decoder_finish_frame (dec, output_buffer, 2);
} else {
return gst_audio_decoder_finish_frame (dec, output_buffer, 1);
}
}
static GstBuffer *
_create_buffer (BufferDesc * bdesc)
{
gchar *tmp = g_strdup (bdesc->content);
GstBuffer *buffer =
gst_buffer_new_wrapped (tmp, strlen (tmp) * sizeof (gchar));
GST_BUFFER_DTS (buffer) = bdesc->dts;
GST_BUFFER_PTS (buffer) = bdesc->pts;
GST_BUFFER_DURATION (buffer) = bdesc->duration;
if (bdesc->keyframe)
GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
else
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
return buffer;
}
static GstFlowReturn
gst_av1_enc_process (GstAV1Enc * encoder)
{
aom_codec_iter_t iter = NULL;
const aom_codec_cx_pkt_t *pkt;
GstVideoCodecFrame *frame;
GstVideoEncoder *video_encoder;
GstFlowReturn ret = GST_FLOW_CUSTOM_SUCCESS;
video_encoder = GST_VIDEO_ENCODER (encoder);
while ((pkt = aom_codec_get_cx_data (&encoder->encoder, &iter)) != NULL) {
if (pkt->kind == AOM_CODEC_STATS_PKT) {
GST_WARNING_OBJECT (encoder, "Unhandled stats packet");
} else if (pkt->kind == AOM_CODEC_FPMB_STATS_PKT) {
GST_WARNING_OBJECT (encoder, "Unhandled FPMB pkt");
} else if (pkt->kind == AOM_CODEC_PSNR_PKT) {
GST_WARNING_OBJECT (encoder, "Unhandled PSNR packet");
} else if (pkt->kind == AOM_CODEC_CX_FRAME_PKT) {
frame = gst_video_encoder_get_oldest_frame (video_encoder);
g_assert (frame != NULL);
if ((pkt->data.frame.flags & AOM_FRAME_IS_KEY) != 0) {
GST_VIDEO_CODEC_FRAME_SET_SYNC_POINT (frame);
} else {
GST_VIDEO_CODEC_FRAME_UNSET_SYNC_POINT (frame);
}
frame->output_buffer =
gst_buffer_new_wrapped (g_memdup (pkt->data.frame.buf,
pkt->data.frame.sz), pkt->data.frame.sz);
if ((pkt->data.frame.flags & AOM_FRAME_IS_DROPPABLE) != 0)
GST_BUFFER_FLAG_SET (frame->output_buffer, GST_BUFFER_FLAG_DROPPABLE);
if ((pkt->data.frame.flags & AOM_FRAME_IS_INVISIBLE) != 0)
GST_BUFFER_FLAG_SET (frame->output_buffer, GST_BUFFER_FLAG_DECODE_ONLY);
ret = gst_video_encoder_finish_frame (video_encoder, frame);
if (ret != GST_FLOW_OK)
break;
}
}
return ret;
}
static void on_key_received(ErDtlsConnection *connection, gpointer key, guint cipher, guint auth, GstErDtlsEnc *self)
{
gpointer key_dup;
gchar *key_str;
g_return_if_fail(GST_IS_ER_DTLS_ENC(self));
g_return_if_fail(ER_IS_DTLS_CONNECTION(connection));
self->srtp_cipher = cipher;
self->srtp_auth = auth;
key_dup = g_memdup(key, ER_DTLS_SRTP_MASTER_KEY_LENGTH);
self->encoder_key = gst_buffer_new_wrapped(key_dup, ER_DTLS_SRTP_MASTER_KEY_LENGTH);
key_str = g_base64_encode(key, ER_DTLS_SRTP_MASTER_KEY_LENGTH);
GST_INFO_OBJECT(self, "received key: %s", key_str);
g_free(key_str);
g_signal_emit(self, signals[SIGNAL_ON_KEY_RECEIVED], 0);
}
static void on_send_data(ErDtlsConnection *connection, gconstpointer data, gint length, GstErDtlsEnc *self)
{
GstBuffer *buffer;
GST_DEBUG_OBJECT(self, "sending data from %s with length %d", self->connection_id, length);
buffer = gst_buffer_new_wrapped(g_memdup(data, length), length);
GST_TRACE_OBJECT(self, "send data: acquiring lock");
g_mutex_lock(&self->queue_lock);
GST_TRACE_OBJECT(self, "send data: acquired lock");
g_ptr_array_add(self->queue, buffer);
GST_TRACE_OBJECT(self, "send data: signaling add");
g_cond_signal(&self->queue_cond_add);
GST_TRACE_OBJECT(self, "send data: releasing lock");
g_mutex_unlock(&self->queue_lock);
}
static GstFlowReturn
gst_video_decoder_tester_handle_frame (GstVideoDecoder * dec,
GstVideoCodecFrame * frame)
{
GstVideoDecoderTester *dectester = (GstVideoDecoderTester *) dec;
guint64 input_num;
guint8 *data;
gint size;
GstMapInfo map;
gst_buffer_map (frame->input_buffer, &map, GST_MAP_READ);
input_num = *((guint64 *) map.data);
if ((input_num == dectester->last_buf_num + 1
&& dectester->last_buf_num != -1)
|| !GST_BUFFER_FLAG_IS_SET (frame->input_buffer,
GST_BUFFER_FLAG_DELTA_UNIT)) {
/* the output is gray8 */
size = TEST_VIDEO_WIDTH * TEST_VIDEO_HEIGHT;
data = g_malloc0 (size);
memcpy (data, map.data, sizeof (guint64));
frame->output_buffer = gst_buffer_new_wrapped (data, size);
frame->pts = GST_BUFFER_PTS (frame->input_buffer);
frame->duration = GST_BUFFER_DURATION (frame->input_buffer);
dectester->last_buf_num = input_num;
if (!GST_BUFFER_FLAG_IS_SET (frame->input_buffer,
GST_BUFFER_FLAG_DELTA_UNIT))
dectester->last_kf_num = input_num;
}
gst_buffer_unmap (frame->input_buffer, &map);
if (frame->output_buffer)
return gst_video_decoder_finish_frame (dec, frame);
gst_video_codec_frame_unref (frame);
return GST_FLOW_OK;
}
static GstBuffer *
create_test_buffer (guint64 num)
{
GstBuffer *buffer;
guint64 *data;
gsize size;
guint64 samples;
samples = TEST_AUDIO_RATE;
size = 2 * 2 * samples;
data = g_malloc0 (size);
*data = num;
buffer = gst_buffer_new_wrapped (data, size);
GST_BUFFER_PTS (buffer) = num * GST_SECOND;
GST_BUFFER_DURATION (buffer) = GST_SECOND;
return buffer;
}
static GstFlowReturn
gst_video_encoder_tester_handle_frame (GstVideoEncoder * dec,
GstVideoCodecFrame * frame)
{
guint8 *data;
GstMapInfo map;
guint64 input_num;
gst_buffer_map (frame->input_buffer, &map, GST_MAP_READ);
input_num = *((guint64 *) map.data);
gst_buffer_unmap (frame->input_buffer, &map);
data = g_malloc (sizeof (guint64));
*(guint64 *) data = input_num;
frame->output_buffer = gst_buffer_new_wrapped (data, sizeof (guint64));
frame->pts = GST_BUFFER_PTS (frame->input_buffer);
frame->duration = GST_BUFFER_DURATION (frame->input_buffer);
return gst_video_encoder_finish_frame (dec, frame);
}
static void
kms_dummy_src_feed_data_channel (GstElement * appsrc, guint unused_size,
gpointer data)
{
KmsDummySrc *self = KMS_DUMMY_SRC (data);
GstClockTime running_time, base_time, now;
GstClock *clock;
GstBuffer *buffer;
gchar *buffer_data;
GstFlowReturn ret;
if ((clock = GST_ELEMENT_CLOCK (appsrc)) == NULL) {
GST_ERROR_OBJECT (GST_ELEMENT (data), "no clock, we can't sync");
return;
}
buffer_data = g_strdup_printf ("Test buffer %d",
g_atomic_int_add (&self->priv->data_index, 1));
buffer = gst_buffer_new_wrapped (buffer_data, strlen (buffer_data));
base_time = GST_ELEMENT_CAST (appsrc)->base_time;
now = gst_clock_get_time (clock);
running_time = now - base_time;
/* Live sources always timestamp their buffers with the running_time of the */
/* pipeline. This is needed to be able to match the timestamps of different */
/* live sources in order to synchronize them. */
GST_BUFFER_PTS (buffer) = running_time;
g_signal_emit_by_name (appsrc, "push-buffer", buffer, &ret);
if (ret != GST_FLOW_OK) {
/* something wrong */
GST_WARNING ("Could not send buffer");
}
gst_buffer_unref (buffer);
}
static void
kms_send_data_new_code (KmsSendData * self, guint64 ts, gchar * type,
gchar * symbol)
{
GstClockTime running_time, base_time, now;
GstClock *clock;
GstBuffer *buffer;
gchar *buffer_data;
GstFlowReturn ret;
if ((clock = GST_ELEMENT_CLOCK (self->priv->appsrc)) == NULL) {
GST_ERROR_OBJECT (GST_ELEMENT (self), "no clock, we can't sync");
return;
}
buffer_data =
g_strdup_printf ("Code detected in time %lu, type %s, symbol %s", ts,
type, symbol);
buffer = gst_buffer_new_wrapped (buffer_data, strlen (buffer_data));
base_time = GST_ELEMENT_CAST (self->priv->appsrc)->base_time;
now = gst_clock_get_time (clock);
running_time = now - base_time;
/* Live sources always timestamp their buffers with the running_time of the */
/* pipeline. This is needed to be able to match the timestamps of different */
/* live sources in order to synchronize them. */
GST_BUFFER_PTS (buffer) = running_time;
g_signal_emit_by_name (self->priv->appsrc, "push-buffer", buffer, &ret);
if (ret != GST_FLOW_OK) {
/* something wrong */
GST_WARNING ("Could not send buffer");
}
gst_buffer_unref (buffer);
}
static GstBuffer* tsmf_get_buffer_from_data(const void* raw_data, gsize size)
{
GstBuffer* buffer;
gpointer data;
if (!raw_data)
return NULL;
if (size < 1)
return NULL;
data = g_malloc(size);
if (!data)
{
WLog_ERR(TAG, "Could not allocate %"G_GSIZE_FORMAT" bytes of data.", size);
return NULL;
}
CopyMemory(data, raw_data, size);
#if GST_VERSION_MAJOR > 0
buffer = gst_buffer_new_wrapped(data, size);
#else
buffer = gst_buffer_new();
if (!buffer)
{
WLog_ERR(TAG, "Could not create GstBuffer");
free(data);
return NULL;
}
GST_BUFFER_MALLOCDATA(buffer) = data;
GST_BUFFER_SIZE(buffer) = size;
GST_BUFFER_DATA(buffer) = GST_BUFFER_MALLOCDATA(buffer);
#endif
return buffer;
}
