/** * gst_clock_get_internal_time: * @clock: a #GstClock to query * * Gets the current internal time of the given clock. The time is returned * unadjusted for the offset and the rate. * * Returns: the internal time of the clock. Or GST_CLOCK_TIME_NONE when * given invalid input. * * MT safe. */ GstClockTime gst_clock_get_internal_time (GstClock * clock) { GstClockTime ret; GstClockClass *cclass; g_return_val_if_fail (GST_IS_CLOCK (clock), GST_CLOCK_TIME_NONE); if (G_UNLIKELY (GST_OBJECT_FLAG_IS_SET (clock, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC) && !clock->priv->synced)) GST_CAT_WARNING_OBJECT (GST_CAT_CLOCK, clock, "clocked is not synchronized yet"); cclass = GST_CLOCK_GET_CLASS (clock); if (G_UNLIKELY (cclass->get_internal_time == NULL)) goto not_supported; ret = cclass->get_internal_time (clock); GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "internal time %" GST_TIME_FORMAT, GST_TIME_ARGS (ret)); return ret; /* ERRORS */ not_supported: { GST_CAT_DEBUG_OBJECT (GST_CAT_CLOCK, clock, "internal time not supported, return 0"); return G_GINT64_CONSTANT (0); } }
static void gst_waveform_sink_reset (GstAudioSink * asink) { GstWaveFormSink *wfsink = GST_WAVEFORM_SINK (asink); MMRESULT mmresult = waveOutReset (wfsink->hwaveout); if (mmresult != MMSYSERR_NOERROR) { waveOutGetErrorText (mmresult, wfsink->error_string, ERROR_LENGTH - 1); GST_CAT_WARNING_OBJECT (waveformsink_debug, wfsink, "gst_waveform_sink_reset: Error reseting waveform-audio device => %s", wfsink->error_string); } }
static gboolean gst_waveform_sink_unprepare (GstAudioSink * asink) { GstWaveFormSink *wfsink = GST_WAVEFORM_SINK (asink); /* free wave buffers */ if (wfsink->wave_buffers) { guint index; for (index = 0; index < wfsink->buffer_count; index++) { if (wfsink->wave_buffers[index].dwFlags & WHDR_PREPARED) { MMRESULT mmresult = waveOutUnprepareHeader (wfsink->hwaveout, &wfsink->wave_buffers[index], sizeof (WAVEHDR)); if (mmresult != MMSYSERR_NOERROR) { waveOutGetErrorText (mmresult, wfsink->error_string, ERROR_LENGTH - 1); GST_CAT_WARNING_OBJECT (waveformsink_debug, wfsink, "gst_waveform_sink_unprepare: Error unpreparing buffer => %s", wfsink->error_string); } } g_free (wfsink->wave_buffers[index].lpData); } g_free (wfsink->wave_buffers); wfsink->wave_buffers = NULL; } /* close waveform-audio output device */ if (wfsink->hwaveout) { waveOutClose (wfsink->hwaveout); wfsink->hwaveout = NULL; } return TRUE; }
static gboolean gst_dshowvideodec_push_buffer (byte * buffer, long size, byte * src_object, UINT64 start, UINT64 stop) { GstDshowVideoDec *vdec = (GstDshowVideoDec *) src_object; GstDshowVideoDecClass *klass = (GstDshowVideoDecClass *) G_OBJECT_GET_CLASS (vdec); GstBuffer *buf = NULL; gboolean in_seg = FALSE; gint64 clip_start = 0, clip_stop = 0; /* check if this buffer is in our current segment */ in_seg = gst_segment_clip (vdec->segment, GST_FORMAT_TIME, start, stop, &clip_start, &clip_stop); /* if the buffer is out of segment do not push it downstream */ if (!in_seg) { GST_CAT_DEBUG_OBJECT (dshowvideodec_debug, vdec, "buffer is out of segment, start %" GST_TIME_FORMAT " stop %" GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (stop)); return FALSE; } /* buffer is in our segment allocate a new out buffer and clip its * timestamps */ vdec->last_ret = gst_pad_alloc_buffer (vdec->srcpad, GST_BUFFER_OFFSET_NONE, size, GST_PAD_CAPS (vdec->srcpad), &buf); if (!buf) { GST_CAT_WARNING_OBJECT (dshowvideodec_debug, vdec, "can't not allocate a new GstBuffer"); return FALSE; } /* set buffer properties */ GST_BUFFER_TIMESTAMP (buf) = clip_start; GST_BUFFER_DURATION (buf) = clip_stop - clip_start; if (strstr (klass->entry->srccaps, "rgb")) { /* FOR RGB directshow decoder will return bottom-up BITMAP * There is probably a way to get top-bottom video frames from * the decoder... */ gint line = 0; guint stride = vdec->width * 4; for (; line < vdec->height; line++) { memcpy (GST_BUFFER_DATA (buf) + (line * stride), buffer + (size - ((line + 1) * (stride))), stride); } } else { memcpy (GST_BUFFER_DATA (buf), buffer, MIN (size, GST_BUFFER_SIZE (buf))); } GST_CAT_LOG_OBJECT (dshowvideodec_debug, vdec, "push_buffer (size %d)=> pts %" GST_TIME_FORMAT " stop %" GST_TIME_FORMAT " duration %" GST_TIME_FORMAT, size, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf)), GST_TIME_ARGS (GST_BUFFER_DURATION (buf))); /* push the buffer downstream */ vdec->last_ret = gst_pad_push (vdec->srcpad, buf); return TRUE; }
gint main (gint argc, gchar * argv[]) { gst_init (&argc, &argv); GST_DEBUG_CATEGORY_INIT (cat_default, "GST_Check_default", 0, "default category for this test"); GST_DEBUG_CATEGORY_INIT (cat2, "GST_Check_2", 0, "second category for this test"); #ifndef GST_DISABLE_GST_DEBUG g_assert (gst_debug_remove_log_function (gst_debug_log_default) == 1); #endif gst_debug_add_log_function (check_message, NULL); count = 0; GST_ERROR ("This is an error."); ++count; GST_WARNING ("This is a warning."); ++count; GST_INFO ("This is an info message."); ++count; GST_DEBUG ("This is a debug message."); ++count; GST_LOG ("This is a log message."); ++count; GST_CAT_ERROR (cat2, "This is an error with category."); ++count; GST_CAT_WARNING (cat2, "This is a warning with category."); ++count; GST_CAT_INFO (cat2, "This is an info message with category."); ++count; GST_CAT_DEBUG (cat2, "This is a debug message with category."); ++count; GST_CAT_LOG (cat2, "This is a log message with category."); count = -1; pipeline = gst_element_factory_make ("pipeline", "testelement"); count = 10; GST_ERROR_OBJECT (pipeline, "This is an error with object."); ++count; GST_WARNING_OBJECT (pipeline, "This is a warning with object."); ++count; GST_INFO_OBJECT (pipeline, "This is an info message with object."); ++count; GST_DEBUG_OBJECT (pipeline, "This is a debug message with object."); ++count; GST_LOG_OBJECT (pipeline, "This is a log message with object."); ++count; GST_CAT_ERROR_OBJECT (cat2, pipeline, "This is an error with category and object."); ++count; GST_CAT_WARNING_OBJECT (cat2, pipeline, "This is a warning with category and object."); ++count; GST_CAT_INFO_OBJECT (cat2, pipeline, "This is an info message with category and object."); ++count; GST_CAT_DEBUG_OBJECT (cat2, pipeline, "This is a debug message with category and object."); ++count; GST_CAT_LOG_OBJECT (cat2, pipeline, "This is a log message with category and object."); count = -1; #ifndef GST_DISABLE_GST_DEBUG g_assert (gst_debug_remove_log_function (check_message) == 1); #endif return 0; }
static guint gst_waveform_sink_write (GstAudioSink * asink, gpointer data, guint length) { GstWaveFormSink *wfsink = GST_WAVEFORM_SINK (asink); WAVEHDR *waveheader; MMRESULT mmresult; guint bytes_to_write = length; guint remaining_length = length; wfsink->bytes_in_queue += length; while (remaining_length > 0) { if (wfsink->free_buffers_count == 0) { /* no free buffer available, wait for one */ Sleep (10); continue; } /* get the current write buffer header */ waveheader = &wfsink->wave_buffers[wfsink->write_buffer]; /* unprepare the header if needed */ if (waveheader->dwFlags & WHDR_PREPARED) { mmresult = waveOutUnprepareHeader (wfsink->hwaveout, waveheader, sizeof (WAVEHDR)); if (mmresult != MMSYSERR_NOERROR) { waveOutGetErrorText (mmresult, wfsink->error_string, ERROR_LENGTH - 1); GST_CAT_WARNING_OBJECT (waveformsink_debug, wfsink, "Error unpreparing buffer => %s", wfsink->error_string); } } if (wfsink->buffer_size - waveheader->dwUser >= remaining_length) bytes_to_write = remaining_length; else bytes_to_write = wfsink->buffer_size - waveheader->dwUser; memcpy (waveheader->lpData + waveheader->dwUser, data, bytes_to_write); waveheader->dwUser += bytes_to_write; remaining_length -= bytes_to_write; data = (byte *) data + bytes_to_write; if (waveheader->dwUser == wfsink->buffer_size) { /* we have filled a buffer, let's prepare it and next write it to the device */ mmresult = waveOutPrepareHeader (wfsink->hwaveout, waveheader, sizeof (WAVEHDR)); if (mmresult != MMSYSERR_NOERROR) { waveOutGetErrorText (mmresult, wfsink->error_string, ERROR_LENGTH - 1); GST_CAT_WARNING_OBJECT (waveformsink_debug, wfsink, "gst_waveform_sink_write: Error preparing header => %s", wfsink->error_string); } mmresult = waveOutWrite (wfsink->hwaveout, waveheader, sizeof (WAVEHDR)); if (mmresult != MMSYSERR_NOERROR) { waveOutGetErrorText (mmresult, wfsink->error_string, ERROR_LENGTH - 1); GST_CAT_WARNING_OBJECT (waveformsink_debug, wfsink, "gst_waveform_sink_write: Error writting buffer to the device => %s", wfsink->error_string); } EnterCriticalSection (&wfsink->critic_wave); wfsink->free_buffers_count--; LeaveCriticalSection (&wfsink->critic_wave); wfsink->write_buffer++; wfsink->write_buffer %= wfsink->buffer_count; waveheader->dwUser = 0; wfsink->bytes_in_queue = 0; GST_CAT_LOG_OBJECT (waveformsink_debug, wfsink, "gst_waveform_sink_write: Writting a buffer to the device (free buffers remaining=%d, write buffer=%d)", wfsink->free_buffers_count, wfsink->write_buffer); } } return length; }