static GstFlowReturn
gst_selector_pad_chain (GstPad * pad, GstBuffer * buf)
{
GstInputSelector *sel;
GstFlowReturn res;
GstPad *active_sinkpad;
GstPad *prev_active_sinkpad;
GstSelectorPad *selpad;
GstClockTime start_time;
GstSegment *seg;
GstEvent *close_event = NULL, *start_event = NULL;
GstCaps *caps;
sel = GST_INPUT_SELECTOR (gst_pad_get_parent (pad));
selpad = GST_SELECTOR_PAD_CAST (pad);
seg = &selpad->segment;
GST_INPUT_SELECTOR_LOCK (sel);
/* wait or check for flushing */
if (gst_input_selector_wait (sel, pad))
goto flushing;
GST_DEBUG_OBJECT (pad, "getting active pad");
prev_active_sinkpad = sel->active_sinkpad;
active_sinkpad = gst_input_selector_activate_sinkpad (sel, pad);
/* update the segment on the srcpad */
start_time = GST_BUFFER_TIMESTAMP (buf);
if (GST_CLOCK_TIME_IS_VALID (start_time)) {
GST_DEBUG_OBJECT (pad, "received start time %" GST_TIME_FORMAT,
GST_TIME_ARGS (start_time));
if (GST_BUFFER_DURATION_IS_VALID (buf))
GST_DEBUG_OBJECT (pad, "received end time %" GST_TIME_FORMAT,
GST_TIME_ARGS (start_time + GST_BUFFER_DURATION (buf)));
GST_OBJECT_LOCK (pad);
gst_segment_set_last_stop (seg, seg->format, start_time);
GST_OBJECT_UNLOCK (pad);
}
/* Ignore buffers from pads except the selected one */
if (pad != active_sinkpad)
goto ignore;
if (G_UNLIKELY (sel->pending_close)) {
GstSegment *cseg = &sel->segment;
GST_DEBUG_OBJECT (sel,
"pushing close NEWSEGMENT update %d, rate %lf, applied rate %lf, "
"format %d, "
"%" G_GINT64_FORMAT " -- %" G_GINT64_FORMAT ", time %"
G_GINT64_FORMAT, TRUE, cseg->rate, cseg->applied_rate, cseg->format,
cseg->start, cseg->stop, cseg->time);
/* create update segment */
close_event = gst_event_new_new_segment_full (TRUE, cseg->rate,
cseg->applied_rate, cseg->format, cseg->start, cseg->stop, cseg->time);
sel->pending_close = FALSE;
}
/* if we have a pending segment, push it out now */
if (G_UNLIKELY (selpad->segment_pending)) {
GST_DEBUG_OBJECT (pad,
"pushing pending NEWSEGMENT update %d, rate %lf, applied rate %lf, "
"format %d, "
"%" G_GINT64_FORMAT " -- %" G_GINT64_FORMAT ", time %"
G_GINT64_FORMAT, FALSE, seg->rate, seg->applied_rate, seg->format,
seg->start, seg->stop, seg->time);
start_event = gst_event_new_new_segment_full (FALSE, seg->rate,
seg->applied_rate, seg->format, seg->start, seg->stop, seg->time);
selpad->segment_pending = FALSE;
}
GST_INPUT_SELECTOR_UNLOCK (sel);
if (prev_active_sinkpad != active_sinkpad && pad == active_sinkpad)
g_object_notify (G_OBJECT (sel), "active-pad");
if (close_event)
gst_pad_push_event (sel->srcpad, close_event);
if (start_event)
gst_pad_push_event (sel->srcpad, start_event);
if (selpad->discont) {
buf = gst_buffer_make_metadata_writable (buf);
GST_DEBUG_OBJECT (pad, "Marking discont buffer %p", buf);
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
selpad->discont = FALSE;
}
/* forward */
GST_DEBUG_OBJECT (pad, "Forwarding buffer %p from pad %s:%s", buf,
GST_DEBUG_PAD_NAME (pad));
if ((caps = GST_BUFFER_CAPS (buf))) {
if (GST_PAD_CAPS (sel->srcpad) != caps)
gst_pad_set_caps (sel->srcpad, caps);
}
res = gst_pad_push (sel->srcpad, buf);
done:
gst_object_unref (sel);
return res;
/* dropped buffers */
ignore:
{
GST_DEBUG_OBJECT (pad, "Pad not active, discard buffer %p", buf);
/* when we drop a buffer, we're creating a discont on this pad */
selpad->discont = TRUE;
GST_INPUT_SELECTOR_UNLOCK (sel);
gst_buffer_unref (buf);
/* figure out what to return upstream */
GST_OBJECT_LOCK (selpad);
if (selpad->always_ok)
res = GST_FLOW_OK;
else
res = GST_FLOW_NOT_LINKED;
GST_OBJECT_UNLOCK (selpad);
goto done;
}
flushing:
{
GST_DEBUG_OBJECT (pad, "We are flushing, discard buffer %p", buf);
GST_INPUT_SELECTOR_UNLOCK (sel);
gst_buffer_unref (buf);
res = GST_FLOW_WRONG_STATE;
goto done;
}
}
void
gst_audio_fx_base_fir_filter_push_residue (GstAudioFXBaseFIRFilter * self)
{
GstBuffer *outbuf;
GstFlowReturn res;
gint rate = GST_AUDIO_FILTER_RATE (self);
gint channels = GST_AUDIO_FILTER_CHANNELS (self);
gint bps = GST_AUDIO_FILTER_BPS (self);
gint outsize, outsamples;
GstMapInfo map;
guint8 *in, *out;
if (channels == 0 || rate == 0 || self->nsamples_in == 0) {
self->buffer_fill = 0;
g_free (self->buffer);
self->buffer = NULL;
return;
}
/* Calculate the number of samples and their memory size that
* should be pushed from the residue */
outsamples = self->nsamples_in - (self->nsamples_out - self->latency);
if (outsamples <= 0) {
self->buffer_fill = 0;
g_free (self->buffer);
self->buffer = NULL;
return;
}
outsize = outsamples * channels * bps;
if (!self->fft || self->low_latency) {
gint64 diffsize, diffsamples;
/* Process the difference between latency and residue length samples
* to start at the actual data instead of starting at the zeros before
* when we only got one buffer smaller than latency */
diffsamples =
((gint64) self->latency) - ((gint64) self->buffer_fill) / channels;
if (diffsamples > 0) {
diffsize = diffsamples * channels * bps;
in = g_new0 (guint8, diffsize);
out = g_new0 (guint8, diffsize);
self->nsamples_out += self->process (self, in, out, diffsamples);
g_free (in);
g_free (out);
}
outbuf = gst_buffer_new_and_alloc (outsize);
/* Convolve the residue with zeros to get the actual remaining data */
in = g_new0 (guint8, outsize);
gst_buffer_map (outbuf, &map, GST_MAP_READWRITE);
self->nsamples_out += self->process (self, in, map.data, outsamples);
gst_buffer_unmap (outbuf, &map);
g_free (in);
} else {
guint gensamples = 0;
outbuf = gst_buffer_new_and_alloc (outsize);
gst_buffer_map (outbuf, &map, GST_MAP_READWRITE);
while (gensamples < outsamples) {
guint step_insamples = self->block_length - self->buffer_fill;
guint8 *zeroes = g_new0 (guint8, step_insamples * channels * bps);
guint8 *out = g_new (guint8, self->block_length * channels * bps);
guint step_gensamples;
step_gensamples = self->process (self, zeroes, out, step_insamples);
g_free (zeroes);
memcpy (map.data + gensamples * bps, out, MIN (step_gensamples,
outsamples - gensamples) * bps);
gensamples += MIN (step_gensamples, outsamples - gensamples);
g_free (out);
}
self->nsamples_out += gensamples;
gst_buffer_unmap (outbuf, &map);
}
/* Set timestamp, offset, etc from the values we
* saved when processing the regular buffers */
if (GST_CLOCK_TIME_IS_VALID (self->start_ts))
GST_BUFFER_TIMESTAMP (outbuf) = self->start_ts;
else
GST_BUFFER_TIMESTAMP (outbuf) = 0;
GST_BUFFER_TIMESTAMP (outbuf) +=
gst_util_uint64_scale_int (self->nsamples_out - outsamples -
self->latency, GST_SECOND, rate);
GST_BUFFER_DURATION (outbuf) =
gst_util_uint64_scale_int (outsamples, GST_SECOND, rate);
if (self->start_off != GST_BUFFER_OFFSET_NONE) {
GST_BUFFER_OFFSET (outbuf) =
self->start_off + self->nsamples_out - outsamples - self->latency;
GST_BUFFER_OFFSET_END (outbuf) = GST_BUFFER_OFFSET (outbuf) + outsamples;
}
GST_DEBUG_OBJECT (self,
"Pushing residue buffer of size %" G_GSIZE_FORMAT " with timestamp: %"
GST_TIME_FORMAT ", duration: %" GST_TIME_FORMAT ", offset: %"
G_GUINT64_FORMAT ", offset_end: %" G_GUINT64_FORMAT ", nsamples_out: %d",
gst_buffer_get_size (outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)), GST_BUFFER_OFFSET (outbuf),
GST_BUFFER_OFFSET_END (outbuf), outsamples);
res = gst_pad_push (GST_BASE_TRANSFORM_CAST (self)->srcpad, outbuf);
if (G_UNLIKELY (res != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed to push residue");
}
self->buffer_fill = 0;
}
static GstFlowReturn
gst_goo_encjpeg_chain (GstPad* pad, GstBuffer* buffer)
{
GST_LOG ("");
GstGooEncJpeg* self = GST_GOO_ENCJPEG (gst_pad_get_parent (pad));
GstGooEncJpegPrivate* priv = GST_GOO_ENCJPEG_GET_PRIVATE (self);
GstFlowReturn ret = GST_FLOW_OK;
GstGooAdapter* adapter = self->adapter;
OMX_BUFFERHEADERTYPE* omx_buffer = NULL;
GstClockTime timestamp, duration;
guint64 offset, offsetend;
GstBuffer* outbuf = NULL;
if (goo_port_is_tunneled (self->inport))
{
GST_INFO ("Inport is tunneled");
ret = GST_FLOW_OK;
priv->incount++;
goto process_output;
}
if (goo_port_is_eos (self->inport))
{
GST_INFO ("port is eos");
ret = GST_FLOW_UNEXPECTED;
goto fail;
}
if (self->component->cur_state != OMX_StateExecuting)
{
goto fail;
}
/* let's copy the timestamp meta data */
timestamp = GST_BUFFER_TIMESTAMP (buffer);
duration = GST_BUFFER_DURATION (buffer);
offset = GST_BUFFER_OFFSET (buffer);
offsetend = GST_BUFFER_OFFSET_END (buffer);
if (GST_IS_GOO_BUFFER (buffer) &&
goo_port_is_my_buffer (self->inport,
GST_GOO_BUFFER (buffer)->omx_buffer))
{
GST_INFO ("My own OMX buffer");
priv->incount++;
gst_buffer_unref (buffer); /* let's push the buffer to omx */
ret = GST_FLOW_OK;
}
else if (GST_IS_GOO_BUFFER (buffer) &&
!goo_port_is_my_buffer (self->inport,
GST_GOO_BUFFER (buffer)->omx_buffer))
{
GST_INFO ("Other OMX buffer");
if (GST_BUFFER_SIZE (buffer) != priv->omxbufsiz)
{
GST_ELEMENT_ERROR (self, STREAM, FORMAT,
("Frame is incomplete (%u!=%u)",
GST_BUFFER_SIZE (buffer),
priv->omxbufsiz),
("Frame is incomplete (%u!=%u)",
GST_BUFFER_SIZE (buffer),
priv->omxbufsiz));
ret = GST_FLOW_ERROR;
}
omx_buffer = goo_port_grab_buffer (self->inport);
memcpy (omx_buffer->pBuffer, GST_BUFFER_DATA (buffer),
priv->omxbufsiz);
omx_buffer->nFilledLen = priv->omxbufsiz;
priv->incount++;
goo_component_release_buffer (self->component, omx_buffer);
gst_buffer_unref (buffer);
ret = GST_FLOW_OK;
}
else
{
if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))
{
gst_goo_adapter_clear (adapter);
}
GST_LOG ("size = %d bytes", GST_BUFFER_SIZE (buffer));
gst_goo_adapter_push (adapter, buffer);
guint tmp = priv->incount;
while (gst_goo_adapter_available (adapter) >= priv->omxbufsiz &&
ret == GST_FLOW_OK)
{
GST_DEBUG ("Pushing data to OMX");
OMX_BUFFERHEADERTYPE* omx_buffer;
omx_buffer = goo_port_grab_buffer (self->inport);
gst_goo_adapter_peek (adapter, priv->omxbufsiz,
omx_buffer);
omx_buffer->nFilledLen = priv->omxbufsiz;
gst_goo_adapter_flush (adapter, priv->omxbufsiz);
priv->incount++;
goo_component_release_buffer (self->component,
omx_buffer);
ret = GST_FLOW_OK;
}
if (tmp == priv->incount)
{
goto done;
}
}
process_output:
if (goo_port_is_tunneled (self->outport))
{
outbuf = gst_ghost_buffer_new ();
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_READONLY);
GST_BUFFER_DATA (outbuf) = NULL;
GST_BUFFER_SIZE (outbuf) = 0;
GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
GST_BUFFER_DURATION (outbuf) = duration;
GST_BUFFER_OFFSET (outbuf) = offset;
GST_BUFFER_OFFSET_END (outbuf) = offsetend;
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (self->srcpad));
gst_pad_push (self->srcpad, outbuf);
goto done;
}
GST_DEBUG ("Poping out buffer from OMX");
omx_buffer = goo_port_grab_buffer (self->outport);
if (omx_buffer->nFilledLen <= 0)
{
ret = GST_FLOW_ERROR;
goto done;
}
if (gst_pad_alloc_buffer (self->srcpad, priv->outcount,
omx_buffer->nFilledLen,
GST_PAD_CAPS (self->srcpad),
&outbuf) == GST_FLOW_OK)
{
priv->outcount++;
/* if the buffer is a goo buffer of the peer element */
if (GST_IS_GOO_BUFFER (outbuf))
{
GST_INFO ("It is a OMX buffer!");
memcpy (GST_GOO_BUFFER (outbuf)->omx_buffer->pBuffer,
omx_buffer->pBuffer, omx_buffer->nFilledLen);
GST_GOO_BUFFER (outbuf)->omx_buffer->nFilledLen =
omx_buffer->nFilledLen;
GST_GOO_BUFFER (outbuf)->omx_buffer->nFlags =
omx_buffer->nFlags;
GST_GOO_BUFFER (outbuf)->omx_buffer->nTimeStamp =
GST2OMX_TIMESTAMP (timestamp);
goo_component_release_buffer (self->component,
omx_buffer);
}
else
{
/* @fixme! */
/* we do this because there is a buffer extarbation
* when a filesink is used.
* Maybe using multiple buffers it could be solved.
*/
memcpy (GST_BUFFER_DATA (outbuf),
omx_buffer->pBuffer, omx_buffer->nFilledLen);
goo_component_release_buffer (self->component,
omx_buffer);
/* gst_buffer_unref (outbuf); */
/* outbuf = GST_BUFFER (gst_goo_buffer_new ()); */
/* gst_goo_buffer_set_data (outbuf, */
/* self->component, */
/* omx_buffer); */
}
GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
GST_BUFFER_DURATION (outbuf) = duration;
GST_BUFFER_OFFSET (outbuf) = offset;
GST_BUFFER_OFFSET_END (outbuf) = offsetend;
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (self->srcpad));
g_signal_emit (G_OBJECT (self),
gst_goo_encjpeg_signals[FRAME_ENCODED], 0);
ret = gst_pad_push (self->srcpad, outbuf);
if (omx_buffer->nFlags & OMX_BUFFERFLAG_EOS ||
goo_port_is_eos (self->outport))
{
GST_INFO ("EOS flag found in output buffer (%d)",
omx_buffer->nFilledLen);
goo_component_set_done (self->component);
}
goto done;
}
else
{
ret = GST_FLOW_ERROR;
goto done;
}
fail:
gst_buffer_unref (buffer);
gst_goo_adapter_clear (adapter);
done:
gst_object_unref (self);
return ret;
}
HRESULT AudioFakeSink::DoRenderSample(IMediaSample *pMediaSample)
{
GstBuffer *out_buf = NULL;
gboolean in_seg = FALSE;
GstClockTime buf_start, buf_stop;
gint64 clip_start = 0, clip_stop = 0;
guint start_offset = 0, stop_offset;
GstClockTime duration;
if(pMediaSample)
{
BYTE *pBuffer = NULL;
LONGLONG lStart = 0, lStop = 0;
long size = pMediaSample->GetActualDataLength();
pMediaSample->GetPointer(&pBuffer);
pMediaSample->GetTime(&lStart, &lStop);
if (!GST_CLOCK_TIME_IS_VALID (mDec->timestamp)) {
// Convert REFERENCE_TIME to GST_CLOCK_TIME
mDec->timestamp = (GstClockTime)lStart * 100;
}
duration = (lStop - lStart) * 100;
buf_start = mDec->timestamp;
buf_stop = mDec->timestamp + duration;
/* save stop position to start next buffer with it */
mDec->timestamp = buf_stop;
/* check if this buffer is in our current segment */
in_seg = gst_segment_clip (mDec->segment, GST_FORMAT_TIME,
buf_start, buf_stop, &clip_start, &clip_stop);
/* if the buffer is out of segment do not push it downstream */
if (!in_seg) {
GST_DEBUG_OBJECT (mDec,
"buffer is out of segment, start %" GST_TIME_FORMAT " stop %"
GST_TIME_FORMAT, GST_TIME_ARGS (buf_start), GST_TIME_ARGS (buf_stop));
goto done;
}
/* buffer is entirely or partially in-segment, so allocate a
* GstBuffer for output, and clip if required */
/* allocate a new buffer for raw audio */
mDec->last_ret = gst_pad_alloc_buffer (mDec->srcpad,
GST_BUFFER_OFFSET_NONE,
size,
GST_PAD_CAPS (mDec->srcpad), &out_buf);
if (!out_buf) {
GST_WARNING_OBJECT (mDec, "cannot allocate a new GstBuffer");
goto done;
}
/* set buffer properties */
GST_BUFFER_TIMESTAMP (out_buf) = buf_start;
GST_BUFFER_DURATION (out_buf) = duration;
memcpy (GST_BUFFER_DATA (out_buf), pBuffer,
MIN ((unsigned int)size, GST_BUFFER_SIZE (out_buf)));
/* we have to remove some heading samples */
if ((GstClockTime) clip_start > buf_start) {
start_offset = (guint)gst_util_uint64_scale_int (clip_start - buf_start,
mDec->rate, GST_SECOND) * mDec->depth / 8 * mDec->channels;
}
else
start_offset = 0;
/* we have to remove some trailing samples */
if ((GstClockTime) clip_stop < buf_stop) {
stop_offset = (guint)gst_util_uint64_scale_int (buf_stop - clip_stop,
mDec->rate, GST_SECOND) * mDec->depth / 8 * mDec->channels;
}
else
stop_offset = size;
/* truncating */
if ((start_offset != 0) || (stop_offset != (size_t) size)) {
GstBuffer *subbuf = gst_buffer_create_sub (out_buf, start_offset,
stop_offset - start_offset);
if (subbuf) {
gst_buffer_set_caps (subbuf, GST_PAD_CAPS (mDec->srcpad));
gst_buffer_unref (out_buf);
out_buf = subbuf;
}
}
GST_BUFFER_TIMESTAMP (out_buf) = clip_start;
GST_BUFFER_DURATION (out_buf) = clip_stop - clip_start;
/* replace the saved stop position by the clipped one */
mDec->timestamp = clip_stop;
GST_DEBUG_OBJECT (mDec,
"push_buffer (size %d)=> pts %" GST_TIME_FORMAT " stop %" GST_TIME_FORMAT
" duration %" GST_TIME_FORMAT, size,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (out_buf)),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (out_buf) +
GST_BUFFER_DURATION (out_buf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (out_buf)));
mDec->last_ret = gst_pad_push (mDec->srcpad, out_buf);
}
done:
return S_OK;
}
static GstFlowReturn
gst_wavenc_write_toc (GstWavEnc * wavenc)
{
GList *list;
GstToc *toc;
GstTocEntry *entry, *subentry;
GstBuffer *buf;
GstMapInfo map;
guint8 *data;
guint32 ncues, size, cues_size, labls_size, notes_size;
if (!wavenc->toc) {
GST_DEBUG_OBJECT (wavenc, "have no toc, checking toc_setter");
wavenc->toc = gst_toc_setter_get_toc (GST_TOC_SETTER (wavenc));
}
if (!wavenc->toc) {
GST_WARNING_OBJECT (wavenc, "have no toc");
return GST_FLOW_OK;
}
toc = gst_toc_ref (wavenc->toc);
size = 0;
cues_size = 0;
labls_size = 0;
notes_size = 0;
/* check if the TOC entries is valid */
list = gst_toc_get_entries (toc);
entry = list->data;
if (gst_toc_entry_is_alternative (entry)) {
list = gst_toc_entry_get_sub_entries (entry);
while (list) {
subentry = list->data;
if (!gst_toc_entry_is_sequence (subentry))
return FALSE;
list = g_list_next (list);
}
list = gst_toc_entry_get_sub_entries (entry);
}
if (gst_toc_entry_is_sequence (entry)) {
while (list) {
entry = list->data;
if (!gst_toc_entry_is_sequence (entry))
return FALSE;
list = g_list_next (list);
}
list = gst_toc_get_entries (toc);
}
ncues = g_list_length (list);
GST_DEBUG_OBJECT (wavenc, "number of cue entries: %d", ncues);
while (list) {
guint32 id = 0;
gint64 id64;
const gchar *uid;
entry = list->data;
uid = gst_toc_entry_get_uid (entry);
id64 = g_ascii_strtoll (uid, NULL, 0);
/* check if id unique compatible with guint32 else generate random */
if (id64 >= 0 && gst_wavenc_is_cue_id_unique (id64, wavenc->cues)) {
id = (guint32) id64;
} else {
do {
id = g_random_int ();
} while (!gst_wavenc_is_cue_id_unique (id, wavenc->cues));
}
gst_wavenc_parse_cue (wavenc, id, entry);
gst_wavenc_parse_labl (wavenc, id, entry);
gst_wavenc_parse_note (wavenc, id, entry);
list = g_list_next (list);
}
/* count cues size */
if (wavenc->cues) {
cues_size = 24 * g_list_length (wavenc->cues);
size += 12 + cues_size;
} else {
GST_WARNING_OBJECT (wavenc, "cue's not found");
return FALSE;
}
/* count labls size */
if (wavenc->labls) {
list = wavenc->labls;
while (list) {
GstWavEncLabl *labl;
labl = list->data;
labls_size += 8 + GST_ROUND_UP_2 (labl->chunk_data_size);
list = g_list_next (list);
}
size += labls_size;
}
/* count notes size */
if (wavenc->notes) {
list = wavenc->notes;
while (list) {
GstWavEncNote *note;
note = list->data;
notes_size += 8 + GST_ROUND_UP_2 (note->chunk_data_size);
list = g_list_next (list);
}
size += notes_size;
}
if (wavenc->labls || wavenc->notes) {
size += 12;
}
buf = gst_buffer_new_and_alloc (size);
gst_buffer_map (buf, &map, GST_MAP_WRITE);
data = map.data;
memset (data, 0, size);
/* write Cue Chunk */
if (wavenc->cues) {
memcpy (data, (gchar *) "cue ", 4);
GST_WRITE_UINT32_LE (data + 4, 4 + cues_size);
GST_WRITE_UINT32_LE (data + 8, ncues);
data += 12;
gst_wavenc_write_cues (&data, wavenc->cues);
/* write Associated Data List Chunk */
if (wavenc->labls || wavenc->notes) {
memcpy (data, (gchar *) "LIST", 4);
GST_WRITE_UINT32_LE (data + 4, 4 + labls_size + notes_size);
memcpy (data + 8, (gchar *) "adtl", 4);
data += 12;
if (wavenc->labls)
gst_wavenc_write_labls (&data, wavenc->labls);
if (wavenc->notes)
gst_wavenc_write_notes (&data, wavenc->notes);
}
}
/* free resources */
if (toc)
gst_toc_unref (toc);
if (wavenc->cues)
g_list_free_full (wavenc->cues, g_free);
if (wavenc->labls)
g_list_free_full (wavenc->labls, g_free);
if (wavenc->notes)
g_list_free_full (wavenc->notes, g_free);
gst_buffer_unmap (buf, &map);
wavenc->meta_length += gst_buffer_get_size (buf);
return gst_pad_push (wavenc->srcpad, buf);
}
static GstFlowReturn
gst_aiff_parse_stream_data (GstAiffParse * aiff)
{
GstBuffer *buf = NULL;
GstFlowReturn res = GST_FLOW_OK;
guint64 desired, obtained;
GstClockTime timestamp, next_timestamp, duration;
guint64 pos, nextpos;
iterate_adapter:
GST_LOG_OBJECT (aiff,
"offset: %" G_GINT64_FORMAT " , end: %" G_GINT64_FORMAT " , dataleft: %"
G_GINT64_FORMAT, aiff->offset, aiff->end_offset, aiff->dataleft);
/* Get the next n bytes and output them */
if (aiff->dataleft == 0 || aiff->dataleft < aiff->bytes_per_sample)
goto found_eos;
/* scale the amount of data by the segment rate so we get equal
* amounts of data regardless of the playback rate */
desired =
MIN (gst_guint64_to_gdouble (aiff->dataleft),
MAX_BUFFER_SIZE * aiff->segment.abs_rate);
if (desired >= aiff->bytes_per_sample && aiff->bytes_per_sample > 0)
desired -= (desired % aiff->bytes_per_sample);
GST_LOG_OBJECT (aiff, "Fetching %" G_GINT64_FORMAT " bytes of data "
"from the sinkpad", desired);
if (aiff->streaming) {
guint avail = gst_adapter_available (aiff->adapter);
if (avail < desired) {
GST_LOG_OBJECT (aiff, "Got only %d bytes of data from the sinkpad",
avail);
return GST_FLOW_OK;
}
buf = gst_adapter_take_buffer (aiff->adapter, desired);
} else {
if ((res = gst_pad_pull_range (aiff->sinkpad, aiff->offset,
desired, &buf)) != GST_FLOW_OK)
goto pull_error;
}
/* If we have a pending close/start segment, send it now. */
if (G_UNLIKELY (aiff->close_segment != NULL)) {
gst_pad_push_event (aiff->srcpad, aiff->close_segment);
aiff->close_segment = NULL;
}
if (G_UNLIKELY (aiff->start_segment != NULL)) {
gst_pad_push_event (aiff->srcpad, aiff->start_segment);
aiff->start_segment = NULL;
}
if (G_UNLIKELY (aiff->tags != NULL)) {
gst_element_found_tags_for_pad (GST_ELEMENT_CAST (aiff), aiff->srcpad,
aiff->tags);
aiff->tags = NULL;
}
obtained = GST_BUFFER_SIZE (buf);
/* our positions in bytes */
pos = aiff->offset - aiff->datastart;
nextpos = pos + obtained;
/* update offsets, does not overflow. */
GST_BUFFER_OFFSET (buf) = pos / aiff->bytes_per_sample;
GST_BUFFER_OFFSET_END (buf) = nextpos / aiff->bytes_per_sample;
if (aiff->bps > 0) {
/* and timestamps if we have a bitrate, be careful for overflows */
timestamp =
gst_util_uint64_scale_ceil (pos, GST_SECOND, (guint64) aiff->bps);
next_timestamp =
gst_util_uint64_scale_ceil (nextpos, GST_SECOND, (guint64) aiff->bps);
duration = next_timestamp - timestamp;
/* update current running segment position */
gst_segment_set_last_stop (&aiff->segment, GST_FORMAT_TIME, next_timestamp);
} else {
/* no bitrate, all we know is that the first sample has timestamp 0, all
* other positions and durations have unknown timestamp. */
if (pos == 0)
timestamp = 0;
else
timestamp = GST_CLOCK_TIME_NONE;
duration = GST_CLOCK_TIME_NONE;
/* update current running segment position with byte offset */
gst_segment_set_last_stop (&aiff->segment, GST_FORMAT_BYTES, nextpos);
}
if (aiff->discont) {
GST_DEBUG_OBJECT (aiff, "marking DISCONT");
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
aiff->discont = FALSE;
}
GST_BUFFER_TIMESTAMP (buf) = timestamp;
GST_BUFFER_DURATION (buf) = duration;
gst_buffer_set_caps (buf, aiff->caps);
GST_LOG_OBJECT (aiff,
"Got buffer. timestamp:%" GST_TIME_FORMAT " , duration:%" GST_TIME_FORMAT
", size:%u", GST_TIME_ARGS (timestamp), GST_TIME_ARGS (duration),
GST_BUFFER_SIZE (buf));
if ((res = gst_pad_push (aiff->srcpad, buf)) != GST_FLOW_OK)
goto push_error;
if (obtained < aiff->dataleft) {
aiff->offset += obtained;
aiff->dataleft -= obtained;
} else {
aiff->offset += aiff->dataleft;
aiff->dataleft = 0;
}
/* Iterate until need more data, so adapter size won't grow */
if (aiff->streaming) {
GST_LOG_OBJECT (aiff,
"offset: %" G_GINT64_FORMAT " , end: %" G_GINT64_FORMAT, aiff->offset,
aiff->end_offset);
goto iterate_adapter;
}
return res;
/* ERROR */
found_eos:
{
GST_DEBUG_OBJECT (aiff, "found EOS");
return GST_FLOW_UNEXPECTED;
}
pull_error:
{
/* check if we got EOS */
if (res == GST_FLOW_UNEXPECTED)
goto found_eos;
GST_WARNING_OBJECT (aiff,
"Error getting %" G_GINT64_FORMAT " bytes from the "
"sinkpad (dataleft = %" G_GINT64_FORMAT ")", desired, aiff->dataleft);
return res;
}
push_error:
{
GST_INFO_OBJECT (aiff,
"Error pushing on srcpad %s:%s, reason %s, is linked? = %d",
GST_DEBUG_PAD_NAME (aiff->srcpad), gst_flow_get_name (res),
gst_pad_is_linked (aiff->srcpad));
return res;
}
}
static GstFlowReturn
fs_funnel_chain (GstPad * pad, GstBuffer * buffer)
{
GstFlowReturn res;
FsFunnel *funnel = FS_FUNNEL (gst_pad_get_parent (pad));
FsFunnelPadPrivate *priv = gst_pad_get_element_private (pad);
GstEvent *event = NULL;
GstClockTime newts;
GstCaps *padcaps;
GST_DEBUG_OBJECT (funnel, "received buffer %p", buffer);
GST_OBJECT_LOCK (funnel);
if (priv->segment.format == GST_FORMAT_UNDEFINED) {
GST_WARNING_OBJECT (funnel, "Got buffer without segment,"
" setting segment [0,inf[");
gst_segment_set_newsegment_full (&priv->segment, FALSE, 1.0, 1.0,
GST_FORMAT_TIME, 0, -1, 0);
}
if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_TIMESTAMP (buffer)))
gst_segment_set_last_stop (&priv->segment, priv->segment.format,
GST_BUFFER_TIMESTAMP (buffer));
newts = gst_segment_to_running_time (&priv->segment,
priv->segment.format, GST_BUFFER_TIMESTAMP (buffer));
if (newts != GST_BUFFER_TIMESTAMP (buffer)) {
buffer = gst_buffer_make_metadata_writable (buffer);
GST_BUFFER_TIMESTAMP (buffer) = newts;
}
if (!funnel->has_segment)
{
event = gst_event_new_new_segment_full (FALSE, 1.0, 1.0, GST_FORMAT_TIME,
0, -1, 0);
funnel->has_segment = TRUE;
}
GST_OBJECT_UNLOCK (funnel);
if (event) {
if (!gst_pad_push_event (funnel->srcpad, event))
GST_WARNING_OBJECT (funnel, "Could not push out newsegment event");
}
GST_OBJECT_LOCK (pad);
padcaps = GST_PAD_CAPS (funnel->srcpad);
GST_OBJECT_UNLOCK (pad);
if (GST_BUFFER_CAPS (buffer) && GST_BUFFER_CAPS (buffer) != padcaps) {
if (!gst_pad_set_caps (funnel->srcpad, GST_BUFFER_CAPS (buffer))) {
res = GST_FLOW_NOT_NEGOTIATED;
goto out;
}
}
res = gst_pad_push (funnel->srcpad, buffer);
GST_LOG_OBJECT (funnel, "handled buffer %s", gst_flow_get_name (res));
out:
gst_object_unref (funnel);
return res;
}
static void
gst_hls_demux_loop (GstHLSDemux * demux)
{
GstBuffer *buf;
GstFlowReturn ret;
/* Loop for the source pad task. The task is started when we have
* received the main playlist from the source element. It tries first to
* cache the first fragments and then it waits until it has more data in the
* queue. This task is woken up when we push a new fragment to the queue or
* when we reached the end of the playlist */
if (G_UNLIKELY (demux->need_cache)) {
if (!gst_hls_demux_cache_fragments (demux))
goto cache_error;
/* we can start now the updates thread (only if on playing) */
if (GST_STATE (demux) == GST_STATE_PLAYING)
gst_hls_demux_start_update (demux);
GST_INFO_OBJECT (demux, "First fragments cached successfully");
}
if (g_queue_is_empty (demux->queue)) {
if (demux->end_of_playlist)
goto end_of_playlist;
goto pause_task;
}
buf = g_queue_pop_head (demux->queue);
/* Figure out if we need to create/switch pads */
if (G_UNLIKELY (!demux->srcpad
|| GST_BUFFER_CAPS (buf) != GST_PAD_CAPS (demux->srcpad)
|| demux->need_segment)) {
switch_pads (demux, GST_BUFFER_CAPS (buf));
demux->need_segment = TRUE;
}
if (demux->need_segment) {
GstClockTime start = demux->position + demux->position_shift;
/* And send a newsegment */
GST_DEBUG_OBJECT (demux, "Sending new-segment. segment start:%"
GST_TIME_FORMAT, GST_TIME_ARGS (start));
gst_pad_push_event (demux->srcpad,
gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME,
start, GST_CLOCK_TIME_NONE, start));
demux->need_segment = FALSE;
demux->position_shift = 0;
}
if (GST_CLOCK_TIME_IS_VALID (GST_BUFFER_DURATION (buf)))
demux->position += GST_BUFFER_DURATION (buf);
ret = gst_pad_push (demux->srcpad, buf);
if (ret != GST_FLOW_OK)
goto error;
return;
end_of_playlist:
{
GST_DEBUG_OBJECT (demux, "Reached end of playlist, sending EOS");
gst_pad_push_event (demux->srcpad, gst_event_new_eos ());
gst_hls_demux_stop (demux);
return;
}
cache_error:
{
gst_task_pause (demux->task);
if (!demux->cancelled) {
GST_ELEMENT_ERROR (demux, RESOURCE, NOT_FOUND,
("Could not cache the first fragments"), (NULL));
gst_hls_demux_stop (demux);
}
return;
}
error:
{
/* FIXME: handle error */
GST_DEBUG_OBJECT (demux, "error, stopping task");
gst_hls_demux_stop (demux);
return;
}
pause_task:
{
gst_task_pause (demux->task);
return;
}
}
static void
gst_live_adder_loop (gpointer data)
{
GstLiveAdder *adder = GST_LIVE_ADDER (data);
GstClockTime buffer_timestamp = 0;
GstClockTime sync_time = 0;
GstClock *clock = NULL;
GstClockID id = NULL;
GstClockReturn ret;
GstBuffer *buffer = NULL;
GstFlowReturn result;
GstEvent *newseg_event = NULL;
GST_OBJECT_LOCK (adder);
again:
for (;;) {
if (adder->srcresult != GST_FLOW_OK)
goto flushing;
if (!g_queue_is_empty (adder->buffers))
break;
if (check_eos_locked (adder))
goto eos;
g_cond_wait (adder->not_empty_cond, GST_OBJECT_GET_LOCK (adder));
}
buffer_timestamp = GST_BUFFER_TIMESTAMP (g_queue_peek_head (adder->buffers));
clock = GST_ELEMENT_CLOCK (adder);
/* If we have no clock, then we can't do anything.. error */
if (!clock) {
if (adder->playing)
goto no_clock;
else
goto push_buffer;
}
GST_DEBUG_OBJECT (adder, "sync to timestamp %" GST_TIME_FORMAT,
GST_TIME_ARGS (buffer_timestamp));
sync_time = buffer_timestamp + GST_ELEMENT_CAST (adder)->base_time;
/* add latency, this includes our own latency and the peer latency. */
sync_time += adder->latency_ms * GST_MSECOND;
sync_time += adder->peer_latency;
/* create an entry for the clock */
id = adder->clock_id = gst_clock_new_single_shot_id (clock, sync_time);
GST_OBJECT_UNLOCK (adder);
ret = gst_clock_id_wait (id, NULL);
GST_OBJECT_LOCK (adder);
/* and free the entry */
gst_clock_id_unref (id);
adder->clock_id = NULL;
/* at this point, the clock could have been unlocked by a timeout, a new
* head element was added to the queue or because we are shutting down. Check
* for shutdown first. */
if (adder->srcresult != GST_FLOW_OK)
goto flushing;
if (ret == GST_CLOCK_UNSCHEDULED) {
GST_DEBUG_OBJECT (adder,
"Wait got unscheduled, will retry to push with new buffer");
goto again;
}
if (ret != GST_CLOCK_OK && ret != GST_CLOCK_EARLY)
goto clock_error;
push_buffer:
buffer = g_queue_pop_head (adder->buffers);
if (!buffer)
goto again;
/*
* We make sure the timestamps are exactly contiguous
* If its only small skew (due to rounding errors), we correct it
* silently. Otherwise we put the discont flag
*/
if (GST_CLOCK_TIME_IS_VALID (adder->next_timestamp) &&
GST_BUFFER_TIMESTAMP (buffer) != adder->next_timestamp) {
GstClockTimeDiff diff = GST_CLOCK_DIFF (GST_BUFFER_TIMESTAMP (buffer),
adder->next_timestamp);
if (diff < 0)
diff = -diff;
if (diff < GST_SECOND / adder->rate) {
GST_BUFFER_TIMESTAMP (buffer) = adder->next_timestamp;
GST_DEBUG_OBJECT (adder, "Correcting slight skew");
GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DISCONT);
} else {
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
GST_DEBUG_OBJECT (adder, "Expected buffer at %" GST_TIME_FORMAT
", but is at %" GST_TIME_FORMAT ", setting discont",
GST_TIME_ARGS (adder->next_timestamp),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)));
}
} else {
GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DISCONT);
}
GST_BUFFER_OFFSET (buffer) = GST_BUFFER_OFFSET_NONE;
GST_BUFFER_OFFSET_END (buffer) = GST_BUFFER_OFFSET_NONE;
if (GST_BUFFER_DURATION_IS_VALID (buffer))
adder->next_timestamp = GST_BUFFER_TIMESTAMP (buffer) +
GST_BUFFER_DURATION (buffer);
else
adder->next_timestamp = GST_CLOCK_TIME_NONE;
if (adder->segment_pending) {
/*
* We set the start at 0, because we re-timestamps to the running time
*/
newseg_event = gst_event_new_new_segment_full (FALSE, 1.0, 1.0,
GST_FORMAT_TIME, 0, -1, 0);
adder->segment_pending = FALSE;
}
GST_OBJECT_UNLOCK (adder);
if (newseg_event)
gst_pad_push_event (adder->srcpad, newseg_event);
GST_LOG_OBJECT (adder, "About to push buffer time:%" GST_TIME_FORMAT
" duration:%" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer)),
GST_TIME_ARGS (GST_BUFFER_DURATION (buffer)));
result = gst_pad_push (adder->srcpad, buffer);
if (result != GST_FLOW_OK)
goto pause;
return;
flushing:
{
GST_DEBUG_OBJECT (adder, "we are flushing");
gst_pad_pause_task (adder->srcpad);
GST_OBJECT_UNLOCK (adder);
return;
}
clock_error:
{
gst_pad_pause_task (adder->srcpad);
GST_OBJECT_UNLOCK (adder);
GST_ELEMENT_ERROR (adder, STREAM, MUX, ("Error with the clock"),
("Error with the clock: %d", ret));
GST_ERROR_OBJECT (adder, "Error with the clock: %d", ret);
return;
}
no_clock:
{
gst_pad_pause_task (adder->srcpad);
GST_OBJECT_UNLOCK (adder);
GST_ELEMENT_ERROR (adder, STREAM, MUX, ("No available clock"),
("No available clock"));
GST_ERROR_OBJECT (adder, "No available clock");
return;
}
pause:
{
GST_DEBUG_OBJECT (adder, "pausing task, reason %s",
gst_flow_get_name (result));
GST_OBJECT_LOCK (adder);
/* store result */
adder->srcresult = result;
/* we don't post errors or anything because upstream will do that for us
* when we pass the return value upstream. */
gst_pad_pause_task (adder->srcpad);
GST_OBJECT_UNLOCK (adder);
return;
}
eos:
{
/* store result, we are flushing now */
GST_DEBUG_OBJECT (adder, "We are EOS, pushing EOS downstream");
adder->srcresult = GST_FLOW_UNEXPECTED;
gst_pad_pause_task (adder->srcpad);
GST_OBJECT_UNLOCK (adder);
gst_pad_push_event (adder->srcpad, gst_event_new_eos ());
return;
}
}
static GstFlowReturn
gst_vp8_enc_pre_push (GstVideoEncoder * video_encoder,
GstVideoCodecFrame * frame)
{
GstVP8Enc *encoder;
GstVPXEnc *vpx_enc;
GstBuffer *buf;
GstFlowReturn ret = GST_FLOW_OK;
GstVP8EncUserData *user_data = gst_video_codec_frame_get_user_data (frame);
GList *l;
gint inv_count;
GstVideoInfo *info;
GST_DEBUG_OBJECT (video_encoder, "pre_push");
encoder = GST_VP8_ENC (video_encoder);
vpx_enc = GST_VPX_ENC (encoder);
info = &vpx_enc->input_state->info;
g_assert (user_data != NULL);
for (inv_count = 0, l = user_data->invisible; l; inv_count++, l = l->next) {
buf = l->data;
l->data = NULL;
/* FIXME : All of this should have already been handled by base classes, no ? */
if (l == user_data->invisible
&& GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame)) {
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance = 0;
} else {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance++;
}
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DECODE_ONLY);
GST_BUFFER_TIMESTAMP (buf) = GST_BUFFER_TIMESTAMP (frame->output_buffer);
GST_BUFFER_DURATION (buf) = 0;
if (GST_VIDEO_INFO_FPS_D (info) == 0 || GST_VIDEO_INFO_FPS_N (info) == 0) {
GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
} else {
GST_BUFFER_OFFSET_END (buf) =
_to_granulepos (frame->presentation_frame_number + 1,
inv_count, encoder->keyframe_distance);
GST_BUFFER_OFFSET (buf) =
gst_util_uint64_scale (frame->presentation_frame_number + 1,
GST_SECOND * GST_VIDEO_INFO_FPS_D (info),
GST_VIDEO_INFO_FPS_N (info));
}
ret = gst_pad_push (GST_VIDEO_ENCODER_SRC_PAD (video_encoder), buf);
if (ret != GST_FLOW_OK) {
GST_WARNING_OBJECT (encoder, "flow error %d", ret);
goto done;
}
}
buf = frame->output_buffer;
/* FIXME : All of this should have already been handled by base classes, no ? */
if (!user_data->invisible && GST_VIDEO_CODEC_FRAME_IS_SYNC_POINT (frame)) {
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance = 0;
} else {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance++;
}
if (GST_VIDEO_INFO_FPS_D (info) == 0 || GST_VIDEO_INFO_FPS_N (info) == 0) {
GST_BUFFER_OFFSET_END (buf) = GST_BUFFER_OFFSET_NONE;
GST_BUFFER_OFFSET (buf) = GST_BUFFER_OFFSET_NONE;
} else {
GST_BUFFER_OFFSET_END (buf) =
_to_granulepos (frame->presentation_frame_number + 1, 0,
encoder->keyframe_distance);
GST_BUFFER_OFFSET (buf) =
gst_util_uint64_scale (frame->presentation_frame_number + 1,
GST_SECOND * GST_VIDEO_INFO_FPS_D (info), GST_VIDEO_INFO_FPS_N (info));
}
GST_LOG_OBJECT (video_encoder, "src ts: %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
done:
return ret;
}
static gboolean
brasero_transcode_buffer_handler (GstPad *pad,
GstBuffer *buffer,
BraseroTranscode *self)
{
BraseroTranscodePrivate *priv;
GstPad *peer;
gint64 size;
priv = BRASERO_TRANSCODE_PRIVATE (self);
size = GST_BUFFER_SIZE (buffer);
if (priv->segment_start <= 0 && priv->segment_end <= 0)
return TRUE;
/* what we do here is more or less what gstreamer does when seeking:
* it reads and process from 0 to the seek position (I tried).
* It even forwards the data before the seek position to the sink (which
* is a problem in our case as it would be written) */
if (priv->size > priv->segment_end) {
priv->size += size;
return FALSE;
}
if (priv->size + size > priv->segment_end) {
GstBuffer *new_buffer;
int data_size;
/* the entire the buffer is not interesting for us */
/* create a new buffer and push it on the pad:
* NOTE: we're going to receive it ... */
data_size = priv->segment_end - priv->size;
new_buffer = gst_buffer_new_and_alloc (data_size);
memcpy (GST_BUFFER_DATA (new_buffer), GST_BUFFER_DATA (buffer), data_size);
/* Recursive: the following calls ourselves BEFORE we finish */
peer = gst_pad_get_peer (pad);
gst_pad_push (peer, new_buffer);
priv->size += size - data_size;
/* post an EOS event to stop pipeline */
gst_pad_push_event (peer, gst_event_new_eos ());
gst_object_unref (peer);
return FALSE;
}
/* see if the buffer is in the segment */
if (priv->size < priv->segment_start) {
GstBuffer *new_buffer;
gint data_size;
/* see if all the buffer is interesting for us */
if (priv->size + size < priv->segment_start) {
priv->size += size;
return FALSE;
}
/* create a new buffer and push it on the pad:
* NOTE: we're going to receive it ... */
data_size = priv->size + size - priv->segment_start;
new_buffer = gst_buffer_new_and_alloc (data_size);
memcpy (GST_BUFFER_DATA (new_buffer),
GST_BUFFER_DATA (buffer) +
GST_BUFFER_SIZE (buffer) -
data_size,
data_size);
GST_BUFFER_TIMESTAMP (new_buffer) = GST_BUFFER_TIMESTAMP (buffer) + data_size;
/* move forward by the size of bytes we dropped */
priv->size += size - data_size;
/* this is recursive the following calls ourselves
* BEFORE we finish */
peer = gst_pad_get_peer (pad);
gst_pad_push (peer, new_buffer);
gst_object_unref (peer);
return FALSE;
}
priv->size += size;
priv->pos += size;
return TRUE;
}
static void
gst_ffmpegenc_flush_buffers (GstFFMpegEnc * ffmpegenc, gboolean send)
{
GstBuffer *outbuf, *inbuf;
gint ret_size;
GST_DEBUG_OBJECT (ffmpegenc, "flushing buffers with sending %d", send);
/* no need to empty codec if there is none */
if (!ffmpegenc->opened)
goto flush;
while (!g_queue_is_empty (ffmpegenc->delay)) {
ffmpegenc_setup_working_buf (ffmpegenc);
ret_size = avcodec_encode_video (ffmpegenc->context,
ffmpegenc->working_buf, ffmpegenc->working_buf_size, NULL);
if (ret_size < 0) { /* there should be something, notify and give up */
#ifndef GST_DISABLE_GST_DEBUG
GstFFMpegEncClass *oclass =
(GstFFMpegEncClass *) (G_OBJECT_GET_CLASS (ffmpegenc));
GST_WARNING_OBJECT (ffmpegenc,
"ffenc_%s: failed to flush buffer", oclass->in_plugin->name);
#endif /* GST_DISABLE_GST_DEBUG */
break;
}
/* save stats info if there is some as well as a stats file */
if (ffmpegenc->file && ffmpegenc->context->stats_out)
if (fprintf (ffmpegenc->file, "%s", ffmpegenc->context->stats_out) < 0)
GST_ELEMENT_ERROR (ffmpegenc, RESOURCE, WRITE,
(("Could not write to file \"%s\"."), ffmpegenc->filename),
GST_ERROR_SYSTEM);
/* handle b-frame delay when no output, so we don't output empty frames */
inbuf = g_queue_pop_head (ffmpegenc->delay);
outbuf = gst_buffer_new_and_alloc (ret_size);
memcpy (GST_BUFFER_DATA (outbuf), ffmpegenc->working_buf, ret_size);
GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (inbuf);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (inbuf);
if (!ffmpegenc->context->coded_frame->key_frame)
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (ffmpegenc->srcpad));
gst_buffer_unref (inbuf);
if (send)
gst_pad_push (ffmpegenc->srcpad, outbuf);
else
gst_buffer_unref (outbuf);
}
flush:
{
/* make sure that we empty the queue, is still needed if we had to break */
while (!g_queue_is_empty (ffmpegenc->delay))
gst_buffer_unref (g_queue_pop_head (ffmpegenc->delay));
}
}
static GstFlowReturn
gst_ffmpegenc_chain_video (GstPad * pad, GstBuffer * inbuf)
{
GstFFMpegEnc *ffmpegenc = (GstFFMpegEnc *) (GST_PAD_PARENT (pad));
GstBuffer *outbuf;
gint ret_size = 0, frame_size;
gboolean force_keyframe;
GST_DEBUG_OBJECT (ffmpegenc,
"Received buffer of time %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (inbuf)));
GST_OBJECT_LOCK (ffmpegenc);
force_keyframe = ffmpegenc->force_keyframe;
ffmpegenc->force_keyframe = FALSE;
GST_OBJECT_UNLOCK (ffmpegenc);
if (force_keyframe)
ffmpegenc->picture->pict_type = FF_I_TYPE;
frame_size = gst_ffmpeg_avpicture_fill ((AVPicture *) ffmpegenc->picture,
GST_BUFFER_DATA (inbuf),
ffmpegenc->context->pix_fmt,
ffmpegenc->context->width, ffmpegenc->context->height);
g_return_val_if_fail (frame_size == GST_BUFFER_SIZE (inbuf), GST_FLOW_ERROR);
ffmpegenc->picture->pts =
gst_ffmpeg_time_gst_to_ff (GST_BUFFER_TIMESTAMP (inbuf) /
ffmpegenc->context->ticks_per_frame, ffmpegenc->context->time_base);
ffmpegenc_setup_working_buf (ffmpegenc);
ret_size = avcodec_encode_video (ffmpegenc->context,
ffmpegenc->working_buf, ffmpegenc->working_buf_size, ffmpegenc->picture);
if (ret_size < 0) {
#ifndef GST_DISABLE_GST_DEBUG
GstFFMpegEncClass *oclass =
(GstFFMpegEncClass *) (G_OBJECT_GET_CLASS (ffmpegenc));
GST_ERROR_OBJECT (ffmpegenc,
"ffenc_%s: failed to encode buffer", oclass->in_plugin->name);
#endif /* GST_DISABLE_GST_DEBUG */
gst_buffer_unref (inbuf);
return GST_FLOW_OK;
}
/* handle b-frame delay when no output, so we don't output empty frames;
* timestamps and so can permute a bit between coding and display order
* but keyframes should still end up with the proper metadata */
g_queue_push_tail (ffmpegenc->delay, inbuf);
if (ret_size)
inbuf = g_queue_pop_head (ffmpegenc->delay);
else
return GST_FLOW_OK;
/* save stats info if there is some as well as a stats file */
if (ffmpegenc->file && ffmpegenc->context->stats_out)
if (fprintf (ffmpegenc->file, "%s", ffmpegenc->context->stats_out) < 0)
GST_ELEMENT_ERROR (ffmpegenc, RESOURCE, WRITE,
(("Could not write to file \"%s\"."), ffmpegenc->filename),
GST_ERROR_SYSTEM);
outbuf = gst_buffer_new_and_alloc (ret_size);
memcpy (GST_BUFFER_DATA (outbuf), ffmpegenc->working_buf, ret_size);
GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (inbuf);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (inbuf);
/* buggy codec may not set coded_frame */
if (ffmpegenc->context->coded_frame) {
if (!ffmpegenc->context->coded_frame->key_frame)
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DELTA_UNIT);
} else
GST_WARNING_OBJECT (ffmpegenc, "codec did not provide keyframe info");
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (ffmpegenc->srcpad));
gst_buffer_unref (inbuf);
/* Reset frame type */
if (ffmpegenc->picture->pict_type)
ffmpegenc->picture->pict_type = 0;
if (force_keyframe) {
gst_pad_push_event (ffmpegenc->srcpad,
gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM,
gst_structure_new ("GstForceKeyUnit",
"timestamp", G_TYPE_UINT64, GST_BUFFER_TIMESTAMP (outbuf),
NULL)));
}
return gst_pad_push (ffmpegenc->srcpad, outbuf);
}
static GstFlowReturn
gst_kate_parse_push_headers (GstKateParse * parse)
{
/* mark and put on caps */
GstCaps *caps;
GstBuffer *outbuf;
kate_packet packet;
GList *headers, *outbuf_list = NULL;
int ret;
gboolean res;
/* get the headers into the caps, passing them to kate as we go */
caps =
gst_kate_util_set_header_on_caps (&parse->element,
gst_pad_get_negotiated_caps (parse->sinkpad), parse->streamheader);
if (G_UNLIKELY (!caps)) {
GST_ELEMENT_ERROR (parse, STREAM, DECODE, (NULL),
("Failed to set headers on caps"));
return GST_FLOW_ERROR;
}
GST_DEBUG_OBJECT (parse, "here are the caps: %" GST_PTR_FORMAT, caps);
res = gst_pad_set_caps (parse->srcpad, caps);
gst_caps_unref (caps);
if (G_UNLIKELY (!res)) {
GST_WARNING_OBJECT (parse->srcpad, "Failed to set caps on source pad");
return GST_FLOW_NOT_NEGOTIATED;
}
headers = parse->streamheader;
while (headers) {
outbuf = GST_BUFFER_CAST (headers->data);
kate_packet_wrap (&packet, GST_BUFFER_SIZE (outbuf),
GST_BUFFER_DATA (outbuf));
ret = kate_decode_headerin (&parse->ki, &parse->kc, &packet);
if (G_UNLIKELY (ret < 0)) {
GST_WARNING_OBJECT (parse, "kate_decode_headerin returned %d", ret);
}
/* takes ownership of outbuf, which was previously in parse->streamheader */
outbuf_list = g_list_append (outbuf_list, outbuf);
headers = headers->next;
}
/* first process queued events */
gst_kate_parse_drain_event_queue (parse);
/* push out buffers, ignoring return value... */
headers = outbuf_list;
while (headers) {
outbuf = GST_BUFFER_CAST (headers->data);
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (parse->srcpad));
gst_pad_push (parse->srcpad, outbuf);
headers = headers->next;
}
g_list_free (outbuf_list);
g_list_free (parse->streamheader);
parse->streamheader = NULL;
parse->streamheader_sent = TRUE;
return GST_FLOW_OK;
}
static gboolean
gst_rtp_ulpfec_dec_handle_packet_loss (GstRtpUlpFecDec * self, guint16 seqnum,
GstClockTime timestamp, GstClockTime duration)
{
gint caps_pt = self->have_caps_pt ? self->caps_pt : -1;
gboolean ret = TRUE;
GstBufferList *buflist =
rtp_storage_get_packets_for_recovery (self->storage, self->fec_pt,
self->caps_ssrc, seqnum);
if (buflist) {
GstBuffer *recovered_buffer = NULL;
guint16 recovered_seq = 0;
guint8 recovered_pt = 0;
gst_rtp_ulpfec_dec_start (self, buflist, self->fec_pt, seqnum);
while (NULL != (recovered_buffer =
gst_rtp_ulpfec_dec_recover (self, self->caps_ssrc, caps_pt,
&recovered_pt, &recovered_seq))) {
if (seqnum == recovered_seq) {
GstBuffer *sent_buffer;
GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
recovered_buffer = gst_buffer_make_writable (recovered_buffer);
GST_BUFFER_PTS (recovered_buffer) = timestamp;
/* GST_BUFFER_DURATION (recovered_buffer) = duration;
* JB does not set the duration, so we will not too */
if (!self->lost_packet_from_storage)
rtp_storage_put_recovered_packet (self->storage,
recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq);
GST_DEBUG_OBJECT (self,
"Pushing recovered packet ssrc=0x%08x seq=%u %" GST_PTR_FORMAT,
self->caps_ssrc, seqnum, recovered_buffer);
sent_buffer = gst_buffer_copy_deep (recovered_buffer);
gst_rtp_buffer_map (sent_buffer, GST_MAP_WRITE, &rtp);
gst_rtp_buffer_set_seq (&rtp, self->next_seqnum++);
gst_rtp_buffer_unmap (&rtp);
ret = FALSE;
self->unset_discont_flag = TRUE;
self->chain_return_val = gst_pad_push (self->srcpad, sent_buffer);
break;
}
rtp_storage_put_recovered_packet (self->storage,
recovered_buffer, recovered_pt, self->caps_ssrc, recovered_seq);
}
gst_rtp_ulpfec_dec_stop (self);
gst_buffer_list_unref (buflist);
}
GST_DEBUG_OBJECT (self, "Packet lost ssrc=0x%08x seq=%u", self->caps_ssrc,
seqnum);
return ret;
}
static GstFlowReturn
gst_monoscope_chain (GstPad * pad, GstBuffer * inbuf)
{
GstFlowReturn flow_ret = GST_FLOW_OK;
GstMonoscope *monoscope;
monoscope = GST_MONOSCOPE (GST_PAD_PARENT (pad));
/* don't try to combine samples from discont buffer */
if (GST_BUFFER_FLAG_IS_SET (inbuf, GST_BUFFER_FLAG_DISCONT)) {
gst_adapter_clear (monoscope->adapter);
monoscope->next_ts = GST_CLOCK_TIME_NONE;
}
/* Match timestamps from the incoming audio */
if (GST_BUFFER_TIMESTAMP (inbuf) != GST_CLOCK_TIME_NONE)
monoscope->next_ts = GST_BUFFER_TIMESTAMP (inbuf);
GST_LOG_OBJECT (monoscope, "in buffer has %d samples, ts=%" GST_TIME_FORMAT,
GST_BUFFER_SIZE (inbuf) / monoscope->bps,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (inbuf)));
gst_adapter_push (monoscope->adapter, inbuf);
inbuf = NULL;
/* Collect samples until we have enough for an output frame */
while (flow_ret == GST_FLOW_OK) {
gint16 *samples;
GstBuffer *outbuf = NULL;
guint32 *pixels, avail, bytesperframe;
avail = gst_adapter_available (monoscope->adapter);
GST_LOG_OBJECT (monoscope, "bytes avail now %u", avail);
/* do negotiation if not done yet, so ->spf etc. is set */
if (GST_PAD_CAPS (monoscope->srcpad) == NULL) {
flow_ret = get_buffer (monoscope, &outbuf);
if (flow_ret != GST_FLOW_OK)
goto out;
gst_buffer_unref (outbuf);
outbuf = NULL;
}
bytesperframe = monoscope->spf * monoscope->bps;
if (avail < bytesperframe)
break;
/* FIXME: something is wrong with QoS, we are skipping way too much
* stuff even with very low CPU loads */
#if 0
if (monoscope->next_ts != -1) {
gboolean need_skip;
gint64 qostime;
qostime = gst_segment_to_running_time (&monoscope->segment,
GST_FORMAT_TIME, monoscope->next_ts);
GST_OBJECT_LOCK (monoscope);
/* check for QoS, don't compute buffers that are known to be late */
need_skip =
GST_CLOCK_TIME_IS_VALID (monoscope->earliest_time) &&
qostime <= monoscope->earliest_time;
GST_OBJECT_UNLOCK (monoscope);
if (need_skip) {
GST_WARNING_OBJECT (monoscope,
"QoS: skip ts: %" GST_TIME_FORMAT ", earliest: %" GST_TIME_FORMAT,
GST_TIME_ARGS (qostime), GST_TIME_ARGS (monoscope->earliest_time));
goto skip;
}
}
#endif
samples = (gint16 *) gst_adapter_peek (monoscope->adapter, bytesperframe);
if (monoscope->spf < 512) {
gint16 in_data[512], i;
for (i = 0; i < 512; ++i) {
gdouble off;
off = ((gdouble) i * (gdouble) monoscope->spf) / 512.0;
in_data[i] = samples[MIN ((guint) off, monoscope->spf)];
}
pixels = monoscope_update (monoscope->visstate, in_data);
} else {
/* not really correct, but looks much prettier */
pixels = monoscope_update (monoscope->visstate, samples);
}
flow_ret = get_buffer (monoscope, &outbuf);
if (flow_ret != GST_FLOW_OK)
goto out;
memcpy (GST_BUFFER_DATA (outbuf), pixels, monoscope->outsize);
GST_BUFFER_TIMESTAMP (outbuf) = monoscope->next_ts;
GST_BUFFER_DURATION (outbuf) = monoscope->frame_duration;
flow_ret = gst_pad_push (monoscope->srcpad, outbuf);
#if 0
skip:
#endif
if (GST_CLOCK_TIME_IS_VALID (monoscope->next_ts))
monoscope->next_ts += monoscope->frame_duration;
gst_adapter_flush (monoscope->adapter, bytesperframe);
}
out:
return flow_ret;
}
static GstFlowReturn
gst_cc_extractor_handle_meta (GstCCExtractor * filter, GstBuffer * buf,
GstVideoCaptionMeta * meta)
{
GstBuffer *outbuf = NULL;
GstEvent *event;
gchar *captionid;
GstFlowReturn flow;
GST_DEBUG_OBJECT (filter, "Handling meta");
/* Check if the meta type matches the configured one */
if (filter->captionpad != NULL && meta->caption_type != filter->caption_type) {
GST_ERROR_OBJECT (filter,
"GstVideoCaptionMeta type changed, Not handled currently");
flow = GST_FLOW_NOT_NEGOTIATED;
goto out;
}
if (filter->captionpad == NULL) {
GstCaps *caption_caps = NULL;
GstEvent *stream_event;
GST_DEBUG_OBJECT (filter, "Creating new caption pad");
switch (meta->caption_type) {
case GST_VIDEO_CAPTION_TYPE_CEA608_RAW:
caption_caps =
gst_caps_from_string ("closedcaption/x-cea-608,format=(string)raw");
break;
case GST_VIDEO_CAPTION_TYPE_CEA608_IN_CEA708_RAW:
caption_caps =
gst_caps_from_string
("closedcaption/x-cea-608,format=(string)cc_data");
break;
case GST_VIDEO_CAPTION_TYPE_CEA708_RAW:
caption_caps =
gst_caps_from_string
("closedcaption/x-cea-708,format=(string)cc_data");
break;
case GST_VIDEO_CAPTION_TYPE_CEA708_CDP:
caption_caps =
gst_caps_from_string ("closedcaption/x-cea-708,format=(string)cdp");
break;
default:
break;
}
if (caption_caps == NULL) {
GST_ERROR_OBJECT (filter, "Unknown/invalid caption type");
return GST_FLOW_NOT_NEGOTIATED;
}
/* Create the caption pad and set the caps */
filter->captionpad =
gst_pad_new_from_static_template (&captiontemplate, "caption");
gst_pad_set_iterate_internal_links_function (filter->sinkpad,
GST_DEBUG_FUNCPTR (gst_cc_extractor_iterate_internal_links));
gst_pad_set_active (filter->captionpad, TRUE);
gst_element_add_pad (GST_ELEMENT (filter), filter->captionpad);
gst_flow_combiner_add_pad (filter->combiner, filter->captionpad);
captionid =
gst_pad_create_stream_id (filter->captionpad, (GstElement *) filter,
"caption");
stream_event = gst_event_new_stream_start (captionid);
g_free (captionid);
/* FIXME : Create a proper stream-id */
if ((event =
gst_pad_get_sticky_event (filter->srcpad, GST_EVENT_STREAM_START,
0))) {
guint group_id;
if (gst_event_parse_group_id (event, &group_id))
gst_event_set_group_id (stream_event, group_id);
gst_event_unref (event);
}
gst_pad_push_event (filter->captionpad, stream_event);
gst_pad_set_caps (filter->captionpad, caption_caps);
gst_caps_unref (caption_caps);
/* Carry over sticky events */
if ((event =
gst_pad_get_sticky_event (filter->srcpad, GST_EVENT_SEGMENT, 0)))
gst_pad_push_event (filter->captionpad, event);
if ((event = gst_pad_get_sticky_event (filter->srcpad, GST_EVENT_TAG, 0)))
gst_pad_push_event (filter->captionpad, event);
filter->caption_type = meta->caption_type;
}
GST_DEBUG_OBJECT (filter,
"Creating new buffer of size %" G_GSIZE_FORMAT " bytes", meta->size);
/* Extract caption data into new buffer with identical buffer timestamps */
outbuf = gst_buffer_new_allocate (NULL, meta->size, NULL);
gst_buffer_fill (outbuf, 0, meta->data, meta->size);
GST_BUFFER_PTS (outbuf) = GST_BUFFER_PTS (buf);
GST_BUFFER_DTS (outbuf) = GST_BUFFER_DTS (buf);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
/* We don't really care about the flow return */
flow = gst_pad_push (filter->captionpad, outbuf);
out:
/* Set flow return on pad and return combined value */
return gst_flow_combiner_update_pad_flow (filter->combiner,
filter->captionpad, flow);
}
static GstFlowReturn
gst_gdk_pixbuf_flush (GstGdkPixbuf * filter)
{
GstBuffer *outbuf;
GdkPixbuf *pixbuf;
int y;
guint8 *out_pix;
guint8 *in_pix;
int in_rowstride;
GstFlowReturn ret;
GstCaps *caps = NULL;
gint n_channels;
pixbuf = gdk_pixbuf_loader_get_pixbuf (filter->pixbuf_loader);
if (pixbuf == NULL)
goto no_pixbuf;
if (filter->image_size == 0) {
filter->width = gdk_pixbuf_get_width (pixbuf);
filter->height = gdk_pixbuf_get_height (pixbuf);
filter->rowstride = gdk_pixbuf_get_rowstride (pixbuf);
filter->image_size = filter->rowstride * filter->height;
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
switch (n_channels) {
case 3:
caps = gst_caps_from_string (GST_VIDEO_CAPS_RGB);
break;
case 4:
caps = gst_caps_from_string (GST_VIDEO_CAPS_RGBA);
break;
default:
goto channels_not_supported;
}
gst_caps_set_simple (caps,
"width", G_TYPE_INT, filter->width,
"height", G_TYPE_INT, filter->height,
"framerate", GST_TYPE_FRACTION, filter->framerate_numerator,
filter->framerate_denominator, NULL);
GST_DEBUG ("Set size to %dx%d", filter->width, filter->height);
gst_pad_set_caps (filter->srcpad, caps);
gst_caps_unref (caps);
}
ret = gst_pad_alloc_buffer_and_set_caps (filter->srcpad,
GST_BUFFER_OFFSET_NONE,
filter->image_size, GST_PAD_CAPS (filter->srcpad), &outbuf);
if (ret != GST_FLOW_OK)
goto no_buffer;
GST_BUFFER_TIMESTAMP (outbuf) = filter->last_timestamp;
GST_BUFFER_DURATION (outbuf) = GST_CLOCK_TIME_NONE;
in_pix = gdk_pixbuf_get_pixels (pixbuf);
in_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
out_pix = GST_BUFFER_DATA (outbuf);
/* FIXME, last line might not have rowstride pixels */
for (y = 0; y < filter->height; y++) {
memcpy (out_pix, in_pix, filter->rowstride);
in_pix += in_rowstride;
out_pix += filter->rowstride;
}
GST_DEBUG ("pushing... %d bytes", GST_BUFFER_SIZE (outbuf));
ret = gst_pad_push (filter->srcpad, outbuf);
if (ret != GST_FLOW_OK)
GST_DEBUG_OBJECT (filter, "flow: %s", gst_flow_get_name (ret));
return ret;
/* ERRORS */
no_pixbuf:
{
GST_ELEMENT_ERROR (filter, STREAM, DECODE, (NULL), ("error geting pixbuf"));
return GST_FLOW_ERROR;
}
channels_not_supported:
{
GST_ELEMENT_ERROR (filter, STREAM, DECODE, (NULL),
("%d channels not supported", n_channels));
return GST_FLOW_ERROR;
}
no_buffer:
{
GST_DEBUG ("Failed to create outbuffer - %s", gst_flow_get_name (ret));
return ret;
}
}
static GstFlowReturn
gst_wavpack_parse_push_buffer (GstWavpackParse * wvparse, GstBuffer * buf,
WavpackHeader * header)
{
GstFlowReturn ret;
wvparse->current_offset += header->ckSize + 8;
wvparse->segment.last_stop = header->block_index;
if (wvparse->need_newsegment) {
if (gst_wavpack_parse_send_newsegment (wvparse, FALSE))
wvparse->need_newsegment = FALSE;
}
/* send any queued events */
if (wvparse->queued_events) {
GList *l;
for (l = wvparse->queued_events; l != NULL; l = l->next) {
gst_pad_push_event (wvparse->srcpad, GST_EVENT (l->data));
}
g_list_free (wvparse->queued_events);
wvparse->queued_events = NULL;
}
if (wvparse->pending_buffer == NULL) {
wvparse->pending_buffer = buf;
wvparse->pending_offset = header->block_index;
} else if (wvparse->pending_offset == header->block_index) {
wvparse->pending_buffer = gst_buffer_join (wvparse->pending_buffer, buf);
} else {
GST_ERROR ("Got incomplete block, dropping");
gst_buffer_unref (wvparse->pending_buffer);
wvparse->pending_buffer = buf;
wvparse->pending_offset = header->block_index;
}
if (!(header->flags & FINAL_BLOCK))
return GST_FLOW_OK;
buf = wvparse->pending_buffer;
wvparse->pending_buffer = NULL;
GST_BUFFER_TIMESTAMP (buf) = gst_util_uint64_scale_int (header->block_index,
GST_SECOND, wvparse->samplerate);
GST_BUFFER_DURATION (buf) = gst_util_uint64_scale_int (header->block_samples,
GST_SECOND, wvparse->samplerate);
GST_BUFFER_OFFSET (buf) = header->block_index;
GST_BUFFER_OFFSET_END (buf) = header->block_index + header->block_samples;
if (wvparse->discont || wvparse->next_block_index != header->block_index) {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
wvparse->discont = FALSE;
}
wvparse->next_block_index = header->block_index + header->block_samples;
gst_buffer_set_caps (buf, GST_PAD_CAPS (wvparse->srcpad));
GST_LOG_OBJECT (wvparse, "Pushing buffer with time %" GST_TIME_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
ret = gst_pad_push (wvparse->srcpad, buf);
wvparse->segment.last_stop = wvparse->next_block_index;
return ret;
}
static void
gst_cdxa_parse_loop (GstPad * sinkpad)
{
GstFlowReturn flow_ret;
GstCDXAParse *cdxa;
GstBuffer *buf = NULL;
gint sync_offset = -1;
cdxa = GST_CDXA_PARSE (GST_PAD_PARENT (sinkpad));
if (cdxa->datasize <= 0) {
GstFormat format = GST_FORMAT_BYTES;
GstPad *peer;
if ((peer = gst_pad_get_peer (sinkpad))) {
if (!gst_pad_query_duration (peer, &format, &cdxa->datasize)) {
GST_DEBUG_OBJECT (cdxa, "Failed to query upstream size!");
gst_object_unref (peer);
goto pause;
}
gst_object_unref (peer);
}
GST_DEBUG_OBJECT (cdxa, "Upstream size: %" G_GINT64_FORMAT, cdxa->datasize);
}
do {
guint req;
req = 8 + GST_CDXA_SECTOR_SIZE; /* riff chunk header = 8 bytes */
buf = NULL;
flow_ret = gst_pad_pull_range (cdxa->sinkpad, cdxa->offset, req, &buf);
if (flow_ret != GST_FLOW_OK) {
GST_DEBUG_OBJECT (cdxa, "Pull flow: %s", gst_flow_get_name (flow_ret));
goto pause;
}
if (GST_BUFFER_SIZE (buf) < req) {
GST_DEBUG_OBJECT (cdxa, "Short read, only got %u/%u bytes",
GST_BUFFER_SIZE (buf), req);
goto eos;
}
sync_offset = gst_cdxa_parse_sync (buf);
gst_buffer_unref (buf);
buf = NULL;
if (sync_offset >= 0)
break;
cdxa->offset += req;
cdxa->bytes_skipped += req;
} while (1);
cdxa->offset += sync_offset;
cdxa->bytes_skipped += sync_offset;
/* first sync frame? */
if (cdxa->datastart < 0) {
GST_LOG_OBJECT (cdxa, "datastart=0x%" G_GINT64_MODIFIER "x", cdxa->offset);
cdxa->datastart = cdxa->offset;
cdxa->bytes_skipped = 0;
cdxa->bytes_sent = 0;
}
GST_DEBUG_OBJECT (cdxa, "pulling buffer at offset 0x%" G_GINT64_MODIFIER "x",
cdxa->offset);
buf = NULL;
flow_ret = gst_pad_pull_range (cdxa->sinkpad, cdxa->offset,
GST_CDXA_SECTOR_SIZE, &buf);
if (flow_ret != GST_FLOW_OK) {
GST_DEBUG_OBJECT (cdxa, "Flow: %s", gst_flow_get_name (flow_ret));
goto pause;
}
if (GST_BUFFER_SIZE (buf) < GST_CDXA_SECTOR_SIZE) {
GST_DEBUG_OBJECT (cdxa, "Short read, only got %u/%u bytes",
GST_BUFFER_SIZE (buf), GST_CDXA_SECTOR_SIZE);
goto eos;
}
buf = gst_cdxa_parse_strip (buf);
GST_DEBUG_OBJECT (cdxa, "pushing buffer %p", buf);
gst_buffer_set_caps (buf, GST_PAD_CAPS (cdxa->srcpad));
cdxa->offset += GST_BUFFER_SIZE (buf);
cdxa->bytes_sent += GST_BUFFER_SIZE (buf);
flow_ret = gst_pad_push (cdxa->srcpad, buf);
if (flow_ret != GST_FLOW_OK) {
GST_DEBUG_OBJECT (cdxa, "Push flow: %s", gst_flow_get_name (flow_ret));
goto pause;
}
return;
eos:
{
GST_DEBUG_OBJECT (cdxa, "Sending EOS");
if (buf)
gst_buffer_unref (buf);
buf = NULL;
gst_pad_push_event (cdxa->srcpad, gst_event_new_eos ());
/* fallthrough */
}
pause:
{
GST_DEBUG_OBJECT (cdxa, "Pausing");
gst_pad_pause_task (cdxa->sinkpad);
return;
}
}
static void
src_task_loop (GstPad * pad)
{
GstDtlsEnc *self = GST_DTLS_ENC (GST_PAD_PARENT (pad));
GstFlowReturn ret;
GstBuffer *buffer;
gboolean check_connection_timeout = FALSE;
GST_TRACE_OBJECT (self, "src loop: acquiring lock");
g_mutex_lock (&self->queue_lock);
GST_TRACE_OBJECT (self, "src loop: acquired lock");
if (self->flushing) {
GST_LOG_OBJECT (self, "src task loop entered on inactive pad");
GST_TRACE_OBJECT (self, "src loop: releasing lock");
g_mutex_unlock (&self->queue_lock);
return;
}
while (g_queue_is_empty (&self->queue)) {
GST_TRACE_OBJECT (self, "src loop: queue empty, waiting for add");
g_cond_wait (&self->queue_cond_add, &self->queue_lock);
GST_TRACE_OBJECT (self, "src loop: add signaled");
if (self->flushing) {
GST_LOG_OBJECT (self, "pad inactive, task returning");
GST_TRACE_OBJECT (self, "src loop: releasing lock");
g_mutex_unlock (&self->queue_lock);
return;
}
}
GST_TRACE_OBJECT (self, "src loop: queue has element");
buffer = g_queue_pop_head (&self->queue);
g_mutex_unlock (&self->queue_lock);
if (self->send_initial_events) {
GstSegment segment;
gchar s_id[32];
GstCaps *caps;
self->send_initial_events = FALSE;
g_snprintf (s_id, sizeof (s_id), "dtlsenc-%08x", g_random_int ());
gst_pad_push_event (self->src, gst_event_new_stream_start (s_id));
caps = gst_caps_new_empty_simple ("application/x-dtls");
gst_pad_push_event (self->src, gst_event_new_caps (caps));
gst_caps_unref (caps);
gst_segment_init (&segment, GST_FORMAT_BYTES);
gst_pad_push_event (self->src, gst_event_new_segment (&segment));
check_connection_timeout = TRUE;
}
GST_TRACE_OBJECT (self, "src loop: releasing lock");
ret = gst_pad_push (self->src, buffer);
if (check_connection_timeout)
gst_dtls_connection_check_timeout (self->connection);
if (G_UNLIKELY (ret != GST_FLOW_OK)) {
GST_WARNING_OBJECT (self, "failed to push buffer on src pad: %s",
gst_flow_get_name (ret));
}
}
static void
gst_droid_cam_src_vfsrc_loop (gpointer data)
{
GstPad *pad = (GstPad *) data;
GstDroidCamSrc *src = GST_DROID_CAM_SRC (GST_OBJECT_PARENT (pad));
GstDroidCamSrcClass *klass = GST_DROID_CAM_SRC_GET_CLASS (src);
GstCameraBufferPool *pool = gst_camera_buffer_pool_ref (src->pool);
GstNativeBuffer *buff;
GstFlowReturn ret;
GList *events = NULL;
GST_LOG_OBJECT (src, "loop");
GST_CAMERA_BUFFER_POOL_LOCK (pool);
if (pool->flushing) {
GST_CAMERA_BUFFER_POOL_UNLOCK (pool);
goto pool_flushing;
}
GST_CAMERA_BUFFER_POOL_UNLOCK (pool);
g_mutex_lock (&pool->app_lock);
if (pool->app_queue->length > 0) {
buff = g_queue_pop_head (pool->app_queue);
g_mutex_unlock (&pool->app_lock);
goto push_buffer;
}
GST_LOG_OBJECT (src, "empty app queue. waiting for buffer");
g_cond_wait (&pool->app_cond, &pool->app_lock);
GST_LOG_OBJECT (src, "done waiting for buffer");
if (pool->app_queue->length == 0) {
/* pool is flushing. */
g_mutex_unlock (&pool->app_lock);
goto pool_flushing;
}
buff = g_queue_pop_head (pool->app_queue);
g_mutex_unlock (&pool->app_lock);
goto push_buffer;
pool_flushing:
/* pause task. */
gst_camera_buffer_pool_unref (src->pool);
GST_DEBUG_OBJECT (src, "pool is flushing. pausing task");
gst_pad_pause_task (pad);
return;
push_buffer:
/* push buffer */
gst_camera_buffer_pool_unref (src->pool);
if (G_UNLIKELY (src->send_new_segment)) {
GST_DEBUG_OBJECT (src, "sending new segment event");
if (!klass->open_segment (src, src->vfsrc)) {
GST_WARNING_OBJECT (src, "failed to push new segment");
}
src->send_new_segment = FALSE;
}
GST_OBJECT_LOCK (src);
if (src->events) {
events = src->events;
src->events = NULL;
}
GST_OBJECT_UNLOCK (src);
while (events) {
GstEvent *ev = g_list_nth_data (events, 0);
events = g_list_remove (events, ev);
GST_DEBUG_OBJECT (src, "pushed event %" GST_PTR_FORMAT, ev);
gst_pad_push_event (src->vfsrc, ev);
}
g_list_free (events);
klass->update_segment (src, GST_BUFFER (buff));
GST_LOG_OBJECT (src, "pushing buffer %p", buff);
ret = gst_pad_push (pad, GST_BUFFER (buff));
if (ret != GST_FLOW_OK) {
goto pause;
}
return;
pause:
GST_DEBUG_OBJECT (src, "pausing task. reason: %s", gst_flow_get_name (ret));
gst_pad_pause_task (pad);
if (ret == GST_FLOW_UNEXPECTED) {
/* perform EOS */
gst_pad_push_event (pad, gst_event_new_eos ());
} else if (ret == GST_FLOW_NOT_LINKED || ret <= GST_FLOW_UNEXPECTED) {
GST_ELEMENT_ERROR (src, STREAM, FAILED,
("Internal data flow error."),
("streaming task paused, reason %s (%d)", gst_flow_get_name (ret),
ret));
/* perform EOS */
gst_pad_push_event (pad, gst_event_new_eos ());
}
}
static GstFlowReturn
gst_tta_dec_chain (GstPad * pad, GstBuffer * in)
{
GstTtaDec *ttadec;
GstBuffer *outbuf, *buf = GST_BUFFER (in);
guchar *data, *p;
decoder *dec;
unsigned long outsize;
unsigned long size;
guint32 frame_samples;
long res;
long *prev;
ttadec = GST_TTA_DEC (GST_OBJECT_PARENT (pad));
data = GST_BUFFER_DATA (buf);
size = GST_BUFFER_SIZE (buf);
ttadec->tta_buf.bit_count = 0;
ttadec->tta_buf.bit_cache = 0;
ttadec->tta_buf.bitpos = ttadec->tta_buf.buffer_end;
ttadec->tta_buf.offset = 0;
decoder_init (ttadec->tta, ttadec->channels, ttadec->bytes);
if (GST_BUFFER_DURATION_IS_VALID (buf)) {
frame_samples =
ceil ((gdouble) (GST_BUFFER_DURATION (buf) * ttadec->samplerate) /
(gdouble) GST_SECOND);
} else {
frame_samples = ttadec->samplerate * FRAME_TIME;
}
outsize = ttadec->channels * frame_samples * ttadec->bytes;
dec = ttadec->tta;
p = ttadec->decdata;
prev = ttadec->cache;
for (res = 0;
p < ttadec->decdata + frame_samples * ttadec->channels * ttadec->bytes;) {
unsigned long unary, binary, depth, k;
long value, temp_value;
fltst *fst = &dec->fst;
adapt *rice = &dec->rice;
long *last = &dec->last;
// decode Rice unsigned
get_unary (&ttadec->tta_buf, data, size, &unary);
switch (unary) {
case 0:
depth = 0;
k = rice->k0;
break;
default:
depth = 1;
k = rice->k1;
unary--;
}
if (k) {
get_binary (&ttadec->tta_buf, data, size, &binary, k);
value = (unary << k) + binary;
} else
value = unary;
switch (depth) {
case 1:
rice->sum1 += value - (rice->sum1 >> 4);
if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
rice->k1--;
else if (rice->sum1 > shift_16[rice->k1 + 1])
rice->k1++;
value += bit_shift[rice->k0];
default:
rice->sum0 += value - (rice->sum0 >> 4);
if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
rice->k0--;
else if (rice->sum0 > shift_16[rice->k0 + 1])
rice->k0++;
}
/* this only uses a temporary variable to silence a gcc warning */
temp_value = DEC (value);
value = temp_value;
// decompress stage 1: adaptive hybrid filter
hybrid_filter (fst, &value);
// decompress stage 2: fixed order 1 prediction
switch (ttadec->bytes) {
case 1:
value += PREDICTOR1 (*last, 4);
break; // bps 8
case 2:
value += PREDICTOR1 (*last, 5);
break; // bps 16
case 3:
value += PREDICTOR1 (*last, 5);
break; // bps 24
case 4:
value += *last;
break; // bps 32
}
*last = value;
if (dec < ttadec->tta + ttadec->channels - 1) {
*prev++ = value;
dec++;
} else {
*prev = value;
if (ttadec->channels > 1) {
long *r = prev - 1;
for (*prev += *r / 2; r >= ttadec->cache; r--)
*r = *(r + 1) - *r;
for (r = ttadec->cache; r < prev; r++)
WRITE_BUFFER (r, ttadec->bytes, p);
}
WRITE_BUFFER (prev, ttadec->bytes, p);
prev = ttadec->cache;
res++;
dec = ttadec->tta;
}
}
outbuf = gst_buffer_new_and_alloc (outsize);
memcpy (GST_BUFFER_DATA (outbuf), ttadec->decdata, outsize);
GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (ttadec->srcpad));
return gst_pad_push (ttadec->srcpad, outbuf);
}
static GstFlowReturn
gst_webvtt_enc_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
{
GstWebvttEnc *webvttenc = GST_WEBVTT_ENC (parent);
GstClockTime ts, dur = GST_SECOND;
GstBuffer *new_buffer;
GstMapInfo map_info;
GstFlowReturn ret;
GString *s;
gsize buf_size;
if (!webvttenc->pushed_header) {
const char *header = "WEBVTT\n\n";
new_buffer = gst_buffer_new_wrapped (g_strdup (header), strlen (header));
GST_BUFFER_PTS (new_buffer) = GST_CLOCK_TIME_NONE;
GST_BUFFER_DURATION (new_buffer) = GST_CLOCK_TIME_NONE;
ret = gst_pad_push (webvttenc->srcpad, new_buffer);
if (ret != GST_FLOW_OK)
goto out;
webvttenc->pushed_header = TRUE;
}
gst_object_sync_values (GST_OBJECT (webvttenc), GST_BUFFER_PTS (buf));
ts = GST_BUFFER_PTS (buf) + webvttenc->timestamp;
if (GST_BUFFER_DURATION_IS_VALID (buf))
dur = GST_BUFFER_DURATION (buf) + webvttenc->duration;
else if (webvttenc->duration > 0)
dur = webvttenc->duration;
else
dur = GST_SECOND;
buf_size = gst_buffer_get_size (buf);
s = g_string_sized_new (50 + buf_size + 1 + 1);
/* start_time --> end_time */
gst_webvtt_enc_append_timestamp_to_string (ts, s);
g_string_append_printf (s, " --> ");
gst_webvtt_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_c (s, '\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);
ret = gst_pad_push (webvttenc->srcpad, new_buffer);
out:
gst_buffer_unref (buf);
return ret;
}
static GstFlowReturn
gst_xvidenc_chain (GstPad * pad, GstBuffer * buf)
{
GstXvidEnc *xvidenc = GST_XVIDENC (GST_PAD_PARENT (pad));
GstBuffer *outbuf;
xvid_enc_frame_t xframe;
const gint motion_presets[] = {
0, 0, 0, 0,
XVID_ME_HALFPELREFINE16,
XVID_ME_HALFPELREFINE16 | XVID_ME_ADVANCEDDIAMOND16,
XVID_ME_HALFPELREFINE16 | XVID_ME_EXTSEARCH16
| XVID_ME_HALFPELREFINE8 | XVID_ME_USESQUARES16
};
if (!xvidenc->handle) {
GST_ELEMENT_ERROR (xvidenc, CORE, NEGOTIATION, (NULL),
("format wasn't negotiated before chain function"));
gst_buffer_unref (buf);
return GST_FLOW_NOT_NEGOTIATED;
}
GST_DEBUG_OBJECT (xvidenc,
"Received buffer of time %" GST_TIME_FORMAT ", size %d",
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_SIZE (buf));
if (xvidenc->xframe_cache)
memcpy (&xframe, xvidenc->xframe_cache, sizeof (xframe));
else { /* need to build some inital xframe to be cached */
/* encode and so ... */
gst_xvid_init_struct (xframe);
if (xvidenc->par_width == xvidenc->par_height)
xframe.par = XVID_PAR_11_VGA;
else {
xframe.par = XVID_PAR_EXT;
xframe.par_width = xvidenc->par_width;
xframe.par_height = xvidenc->par_height;
}
/* handle options */
xframe.vol_flags |= xvidenc->quant_type;
xframe.vop_flags = XVID_VOP_HALFPEL;
xframe.motion = motion_presets[xvidenc->motion];
if (xvidenc->me_chroma) {
xframe.motion |= XVID_ME_CHROMA_PVOP;
xframe.motion |= XVID_ME_CHROMA_BVOP;
}
if (xvidenc->me_vhq >= 1) {
xframe.vop_flags |= XVID_VOP_MODEDECISION_RD;
}
if (xvidenc->me_vhq >= 2) {
xframe.motion |= XVID_ME_HALFPELREFINE16_RD;
xframe.motion |= XVID_ME_QUARTERPELREFINE16_RD;
}
if (xvidenc->me_vhq >= 3) {
xframe.motion |= XVID_ME_HALFPELREFINE8_RD;
xframe.motion |= XVID_ME_QUARTERPELREFINE8_RD;
xframe.motion |= XVID_ME_CHECKPREDICTION_RD;
}
if (xvidenc->me_vhq >= 4) {
xframe.motion |= XVID_ME_EXTSEARCH_RD;
}
/* no motion estimation, then only intra */
if (xvidenc->motion == 0) {
xframe.type = XVID_TYPE_IVOP;
} else {
xframe.type = XVID_TYPE_AUTO;
}
if (xvidenc->motion > 4) {
xframe.vop_flags |= XVID_VOP_INTER4V;
}
if (xvidenc->me_quarterpel) {
xframe.vol_flags |= XVID_VOL_QUARTERPEL;
xframe.motion |= XVID_ME_QUARTERPELREFINE16;
xframe.motion |= XVID_ME_QUARTERPELREFINE8;
}
if (xvidenc->gmc) {
xframe.vol_flags |= XVID_VOL_GMC;
xframe.motion |= XVID_ME_GME_REFINE;
}
if (xvidenc->interlaced) {
xframe.vol_flags |= XVID_VOL_INTERLACING;
}
if (xvidenc->trellis) {
xframe.vop_flags |= XVID_VOP_TRELLISQUANT;
}
if (xvidenc->hqacpred) {
xframe.vop_flags |= XVID_VOP_HQACPRED;
}
if (xvidenc->greyscale) {
xframe.vop_flags |= XVID_VOP_GREYSCALE;
}
if (xvidenc->cartoon) {
xframe.vop_flags |= XVID_VOP_CARTOON;
xframe.motion |= XVID_ME_DETECT_STATIC_MOTION;
}
xframe.bframe_threshold = xvidenc->bframe_threshold;
xframe.input.csp = xvidenc->csp;
/* save in cache */
xvidenc->xframe_cache = g_memdup (&xframe, sizeof (xframe));
}
outbuf = gst_xvidenc_encode (xvidenc, buf, xframe);
if (!outbuf) /* error or no data yet */
return GST_FLOW_OK;
/* go out, multiply! */
return gst_pad_push (xvidenc->srcpad, outbuf);
}
static GstFlowReturn
gst_rtp_ssrc_demux_rtcp_chain (GstPad * pad, GstBuffer * buf)
{
GstFlowReturn ret;
GstRtpSsrcDemux *demux;
guint32 ssrc;
GstRtpSsrcDemuxPad *dpad;
GstRTCPPacket packet;
demux = GST_RTP_SSRC_DEMUX (GST_OBJECT_PARENT (pad));
if (!gst_rtcp_buffer_validate (buf))
goto invalid_rtcp;
if (!gst_rtcp_buffer_get_first_packet (buf, &packet))
goto invalid_rtcp;
/* first packet must be SR or RR or else the validate would have failed */
switch (gst_rtcp_packet_get_type (&packet)) {
case GST_RTCP_TYPE_SR:
/* get the ssrc so that we can route it to the right source pad */
gst_rtcp_packet_sr_get_sender_info (&packet, &ssrc, NULL, NULL, NULL,
NULL);
break;
default:
goto unexpected_rtcp;
}
GST_DEBUG_OBJECT (demux, "received RTCP of SSRC %08x", ssrc);
GST_PAD_LOCK (demux);
dpad = find_demux_pad_for_ssrc (demux, ssrc);
if (dpad == NULL) {
GST_DEBUG_OBJECT (demux, "creating pad for SSRC %08x", ssrc);
if (!(dpad = create_demux_pad_for_ssrc (demux, ssrc, -1)))
goto create_failed;
}
GST_PAD_UNLOCK (demux);
/* push to srcpad */
ret = gst_pad_push (dpad->rtcp_pad, buf);
return ret;
/* ERRORS */
invalid_rtcp:
{
/* this is fatal and should be filtered earlier */
GST_ELEMENT_ERROR (demux, STREAM, DECODE, (NULL),
("Dropping invalid RTCP packet"));
gst_buffer_unref (buf);
return GST_FLOW_ERROR;
}
unexpected_rtcp:
{
GST_DEBUG_OBJECT (demux, "dropping unexpected RTCP packet");
gst_buffer_unref (buf);
return GST_FLOW_OK;
}
create_failed:
{
GST_ELEMENT_ERROR (demux, STREAM, DECODE, (NULL),
("Could not create new pad"));
GST_PAD_UNLOCK (demux);
gst_buffer_unref (buf);
return GST_FLOW_ERROR;
}
}
static GstFlowReturn
gst_mulawenc_chain (GstPad * pad, GstBuffer * buffer)
{
GstMuLawEnc *mulawenc;
gint16 *linear_data;
guint linear_size;
guint8 *mulaw_data;
guint mulaw_size;
GstBuffer *outbuf;
GstFlowReturn ret;
GstClockTime timestamp, duration;
mulawenc = GST_MULAWENC (gst_pad_get_parent (pad));
if (!mulawenc->rate || !mulawenc->channels)
goto not_negotiated;
linear_data = (gint16 *) GST_BUFFER_DATA (buffer);
linear_size = GST_BUFFER_SIZE (buffer);
mulaw_size = linear_size / 2;
timestamp = GST_BUFFER_TIMESTAMP (buffer);
duration = GST_BUFFER_DURATION (buffer);
ret = gst_pad_alloc_buffer_and_set_caps (mulawenc->srcpad,
GST_BUFFER_OFFSET_NONE, mulaw_size, GST_PAD_CAPS (mulawenc->srcpad),
&outbuf);
if (ret != GST_FLOW_OK)
goto alloc_failed;
if (duration == -1) {
duration = gst_util_uint64_scale_int (mulaw_size,
GST_SECOND, mulawenc->rate * mulawenc->channels);
}
if (GST_BUFFER_SIZE (outbuf) < mulaw_size) {
/* pad-alloc can suggest a smaller size */
gst_buffer_unref (outbuf);
outbuf = gst_buffer_new_and_alloc (mulaw_size);
}
mulaw_data = (guint8 *) GST_BUFFER_DATA (outbuf);
/* copy discont flag */
if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
GST_BUFFER_TIMESTAMP (outbuf) = timestamp;
GST_BUFFER_DURATION (outbuf) = duration;
gst_buffer_set_caps (outbuf, GST_PAD_CAPS (mulawenc->srcpad));
mulaw_encode (linear_data, mulaw_data, mulaw_size);
gst_buffer_unref (buffer);
ret = gst_pad_push (mulawenc->srcpad, outbuf);
done:
gst_object_unref (mulawenc);
return ret;
not_negotiated:
{
GST_DEBUG_OBJECT (mulawenc, "no format negotiated");
ret = GST_FLOW_NOT_NEGOTIATED;
gst_buffer_unref (buffer);
goto done;
}
alloc_failed:
{
GST_DEBUG_OBJECT (mulawenc, "pad alloc failed");
gst_buffer_unref (buffer);
goto done;
}
}
static void
spc_play (GstPad * pad)
{
GstSpcDec *spc = GST_SPC_DEC (gst_pad_get_parent (pad));
GstFlowReturn flow_return;
GstBuffer *out;
gboolean seeking = spc->seeking;
gint64 duration, fade, end, position;
if (!seeking) {
out = gst_buffer_new_and_alloc (1600 * 4);
gst_buffer_set_caps (out, GST_PAD_CAPS (pad));
GST_BUFFER_TIMESTAMP (out) =
(gint64) gst_util_uint64_scale ((guint64) spc->byte_pos, GST_SECOND,
32000 * 2 * 2);
spc->byte_pos += OSPC_Run (-1, (short *) GST_BUFFER_DATA (out), 1600 * 4);
} else {
if (spc->seekpoint < spc->byte_pos) {
OSPC_Init (GST_BUFFER_DATA (spc->buf), GST_BUFFER_SIZE (spc->buf));
spc->byte_pos = 0;
}
spc->byte_pos += OSPC_Run (-1, NULL, 1600 * 4);
if (spc->byte_pos >= spc->seekpoint) {
spc->seeking = FALSE;
}
out = gst_buffer_new ();
gst_buffer_set_caps (out, GST_PAD_CAPS (pad));
}
duration = gst_spc_duration (spc);
fade = gst_spc_fadeout (spc);
end = duration + fade;
position =
(gint64) gst_util_uint64_scale ((guint64) spc->byte_pos, GST_SECOND,
32000 * 2 * 2);
if (position >= duration) {
gint16 *data = (gint16 *) GST_BUFFER_DATA (out);
guint32 size = GST_BUFFER_SIZE (out) / sizeof (gint16);
unsigned int i;
gint64 num = (fade - (position - duration));
for (i = 0; i < size; i++) {
/* Apply a parabolic volume envelope */
data[i] = (gint16) (data[i] * num / fade * num / fade);
}
}
if ((flow_return = gst_pad_push (spc->srcpad, out)) != GST_FLOW_OK) {
GST_DEBUG_OBJECT (spc, "pausing task, reason %s",
gst_flow_get_name (flow_return));
gst_pad_pause_task (pad);
if (flow_return <= GST_FLOW_UNEXPECTED
|| flow_return == GST_FLOW_NOT_LINKED) {
gst_pad_push_event (pad, gst_event_new_eos ());
}
}
if (position >= end) {
gst_pad_pause_task (pad);
gst_pad_push_event (pad, gst_event_new_eos ());
}
gst_object_unref (spc);
return;
}
static GstFlowReturn
test_injector_chain (GstPad * pad, GstBuffer * buf)
{
GstFlowReturn ret;
GstPad *srcpad;
srcpad = gst_element_get_pad (GST_ELEMENT (GST_PAD_PARENT (pad)), "src");
/* since we're increasing timestamp/offsets, push this one first */
GST_LOG (" passing buffer [t=%" GST_TIME_FORMAT "-%" GST_TIME_FORMAT
"], offset=%" G_GINT64_FORMAT ", offset_end=%" G_GINT64_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf) + GST_BUFFER_DURATION (buf)),
GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET_END (buf));
gst_buffer_ref (buf);
ret = gst_pad_push (srcpad, buf);
if (g_random_double () < injector_inject_probability) {
GstBuffer *ibuf;
ibuf = gst_buffer_copy (buf);
if (GST_BUFFER_OFFSET_IS_VALID (buf) &&
GST_BUFFER_OFFSET_END_IS_VALID (buf)) {
guint64 delta;
delta = GST_BUFFER_OFFSET_END (buf) - GST_BUFFER_OFFSET (buf);
GST_BUFFER_OFFSET (ibuf) += delta / 4;
GST_BUFFER_OFFSET_END (ibuf) += delta / 4;
} else {
GST_BUFFER_OFFSET (ibuf) = GST_BUFFER_OFFSET_NONE;
GST_BUFFER_OFFSET_END (ibuf) = GST_BUFFER_OFFSET_NONE;
}
if (GST_BUFFER_TIMESTAMP_IS_VALID (buf) &&
GST_BUFFER_DURATION_IS_VALID (buf)) {
GstClockTime delta;
delta = GST_BUFFER_DURATION (buf);
GST_BUFFER_TIMESTAMP (ibuf) += delta / 4;
} else {
GST_BUFFER_TIMESTAMP (ibuf) = GST_CLOCK_TIME_NONE;
GST_BUFFER_DURATION (ibuf) = GST_CLOCK_TIME_NONE;
}
if (GST_BUFFER_TIMESTAMP_IS_VALID (ibuf) ||
GST_BUFFER_OFFSET_IS_VALID (ibuf)) {
GST_LOG ("injecting buffer [t=%" GST_TIME_FORMAT "-%" GST_TIME_FORMAT
"], offset=%" G_GINT64_FORMAT ", offset_end=%" G_GINT64_FORMAT,
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (ibuf)),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (ibuf) +
GST_BUFFER_DURATION (ibuf)), GST_BUFFER_OFFSET (ibuf),
GST_BUFFER_OFFSET_END (ibuf));
if (gst_pad_push (srcpad, ibuf) != GST_FLOW_OK) {
/* ignore return value */
}
} else {
GST_WARNING ("couldn't inject buffer, no incoming timestamps or offsets");
gst_buffer_unref (ibuf);
}
}
gst_buffer_unref (buf);
return ret;
}
static GstFlowReturn
gst_vp8_enc_shape_output (GstBaseVideoEncoder * base_video_encoder,
GstVideoFrame * frame)
{
GstVP8Enc *encoder;
GstBuffer *buf;
const GstVideoState *state;
GstFlowReturn ret;
GstVP8EncCoderHook *hook = frame->coder_hook;
GList *l;
gint inv_count;
GST_DEBUG_OBJECT (base_video_encoder, "shape_output");
encoder = GST_VP8_ENC (base_video_encoder);
state = gst_base_video_encoder_get_state (base_video_encoder);
g_assert (hook != NULL);
for (inv_count = 0, l = hook->invisible; l; inv_count++, l = l->next) {
buf = l->data;
l->data = NULL;
if (l == hook->invisible && frame->is_sync_point) {
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance = 0;
} else {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance++;
}
GST_BUFFER_OFFSET_END (buf) =
_to_granulepos (frame->presentation_frame_number + 1,
inv_count, encoder->keyframe_distance);
GST_BUFFER_OFFSET (buf) =
gst_util_uint64_scale (frame->presentation_frame_number + 1,
GST_SECOND * state->fps_d, state->fps_n);
gst_buffer_set_caps (buf, GST_BASE_VIDEO_CODEC (base_video_encoder)->caps);
ret = gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
if (ret != GST_FLOW_OK) {
GST_WARNING_OBJECT (encoder, "flow error %d", ret);
goto done;
}
}
buf = frame->src_buffer;
frame->src_buffer = NULL;
if (!hook->invisible && frame->is_sync_point) {
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance = 0;
} else {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
encoder->keyframe_distance++;
}
GST_BUFFER_OFFSET_END (buf) =
_to_granulepos (frame->presentation_frame_number + 1, 0,
encoder->keyframe_distance);
GST_BUFFER_OFFSET (buf) =
gst_util_uint64_scale (frame->presentation_frame_number + 1,
GST_SECOND * state->fps_d, state->fps_n);
ret = gst_pad_push (GST_BASE_VIDEO_CODEC_SRC_PAD (base_video_encoder), buf);
if (ret != GST_FLOW_OK) {
GST_WARNING_OBJECT (encoder, "flow error %d", ret);
}
done:
if (hook) {
g_list_foreach (hook->invisible, (GFunc) _gst_mini_object_unref0, NULL);
g_list_free (hook->invisible);
g_slice_free (GstVP8EncCoderHook, hook);
frame->coder_hook = NULL;
}
return ret;
}
