static GstFlowReturn
gst_rsvg_dec_parse (GstVideoDecoder * decoder, GstVideoCodecFrame * frame,
GstAdapter * adapter, gboolean at_eos)
{
GstRsvgDec *rsvg = GST_RSVG_DEC (decoder);
gboolean completed = FALSE;
const guint8 *data;
guint size;
guint i;
GST_LOG_OBJECT (rsvg, "parse start");
size = gst_adapter_available (adapter);
/* "<svg></svg>" */
if (size < 5 + 6)
return GST_VIDEO_DECODER_FLOW_NEED_DATA;
data = gst_adapter_map (adapter, size);
if (data == NULL) {
GST_ERROR_OBJECT (rsvg, "Unable to map memory");
return GST_FLOW_ERROR;
}
for (i = 0; i < size - 4; i++) {
if (memcmp (data + i, "<svg", 4) == 0) {
gst_adapter_flush (adapter, i);
size = gst_adapter_available (adapter);
if (size < 5 + 6)
return GST_VIDEO_DECODER_FLOW_NEED_DATA;
data = gst_adapter_map (adapter, size);
if (data == NULL) {
GST_ERROR_OBJECT (rsvg, "Unable to map memory");
return GST_FLOW_ERROR;
}
break;
}
}
/* If start wasn't found: */
if (i == size - 4) {
gst_adapter_flush (adapter, size - 4);
return GST_VIDEO_DECODER_FLOW_NEED_DATA;
}
for (i = size - 6; i >= 5; i--) {
if (memcmp (data + i, "</svg>", 6) == 0) {
completed = TRUE;
size = i + 6;
break;
}
}
if (completed) {
GST_LOG_OBJECT (rsvg, "have complete svg of %u bytes", size);
gst_video_decoder_add_to_frame (decoder, size);
return gst_video_decoder_have_frame (decoder);
}
return GST_VIDEO_DECODER_FLOW_NEED_DATA;
}
static gboolean
gst_wavpack_parse_resync_adapter (GstAdapter * adapter)
{
const guint8 *buf, *marker;
guint avail = gst_adapter_available (adapter);
if (avail < 4)
return FALSE;
/* if the marker is at the beginning don't do the expensive search */
buf = gst_adapter_peek (adapter, 4);
if (memcmp (buf, "wvpk", 4) == 0)
return TRUE;
if (avail == 4)
return FALSE;
/* search for the marker in the complete content of the adapter */
buf = gst_adapter_peek (adapter, avail);
if (buf && (marker = gst_wavpack_parse_find_marker ((guint8 *) buf, avail))) {
gst_adapter_flush (adapter, marker - buf);
return TRUE;
}
/* flush everything except the last 4 bytes. they could contain
* the start of a new marker */
gst_adapter_flush (adapter, avail - 4);
return FALSE;
}
static GstFlowReturn gst_pocketsphinx_render (GstBaseSink * asink, GstBuffer * buffer)
{
GstPocketSphinx *sphinxsink = GST_POCKETSPHINX (asink);
if (!sphinxsink->ad.initialized) {
g_signal_emit (sphinxsink,
gst_pocketsphinx_signals[SIGNAL_INITIALIZATION], 0, NULL);
/* We initialized the cmd_ln module earlier. */
fbs_init(0, NULL);
g_signal_emit (sphinxsink,
gst_pocketsphinx_signals[SIGNAL_AFTER_INITIALIZATION], 0, NULL);
sphinxsink->ad.initialized = TRUE;
}
gst_buffer_ref (buffer);
gst_adapter_push (sphinxsink->adapter, buffer);
while (gst_adapter_available (sphinxsink->adapter) >= REQUIRED_FRAME_BYTES) {
if (sphinxsink->ad.calibrated) {
gst_pocketsphinx_process_chunk (sphinxsink);
} else {
gst_pocketsphinx_calibrate_chunk (sphinxsink);
}
gst_adapter_flush (sphinxsink->adapter, REQUIRED_FRAME_BYTES);
}
return GST_FLOW_OK;
}
static GstFlowReturn
gst_rtp_g723_pay_flush (GstRTPG723Pay * pay)
{
GstBuffer *outbuf;
GstFlowReturn ret;
guint8 *payload;
guint avail;
avail = gst_adapter_available (pay->adapter);
outbuf = gst_rtp_buffer_new_allocate (avail, 0, 0);
payload = gst_rtp_buffer_get_payload (outbuf);
GST_BUFFER_TIMESTAMP (outbuf) = pay->timestamp;
GST_BUFFER_DURATION (outbuf) = pay->duration;
/* copy G723 data as payload */
gst_adapter_copy (pay->adapter, payload, 0, avail);
/* flush bytes from adapter */
gst_adapter_flush (pay->adapter, avail);
pay->timestamp = GST_CLOCK_TIME_NONE;
pay->duration = 0;
/* set discont and marker */
if (pay->discont) {
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
gst_rtp_buffer_set_marker (outbuf, TRUE);
pay->discont = FALSE;
}
ret = gst_basertppayload_push (GST_BASE_RTP_PAYLOAD (pay), outbuf);
return ret;
}
static gboolean
gst_droidadec_stop (GstAudioDecoder * decoder)
{
GstDroidADec *dec = GST_DROIDADEC (decoder);
GST_DEBUG_OBJECT (dec, "stop");
if (dec->codec) {
droid_media_codec_stop (dec->codec);
droid_media_codec_destroy (dec->codec);
dec->codec = NULL;
}
gst_adapter_flush (dec->adapter, gst_adapter_available (dec->adapter));
g_mutex_lock (&dec->eos_lock);
dec->eos = FALSE;
g_mutex_unlock (&dec->eos_lock);
gst_buffer_replace (&dec->codec_data, NULL);
if (dec->codec_type) {
gst_droid_codec_unref (dec->codec_type);
dec->codec_type = NULL;
}
return TRUE;
}
static GstFlowReturn
gst_rtp_mp2t_pay_flush (GstRTPMP2TPay * rtpmp2tpay)
{
guint avail;
guint8 *payload;
GstFlowReturn ret;
GstBuffer *outbuf;
avail = gst_adapter_available (rtpmp2tpay->adapter);
if (avail == 0)
return GST_FLOW_OK;
outbuf = gst_rtp_buffer_new_allocate (avail, 0, 0);
/* get payload */
payload = gst_rtp_buffer_get_payload (outbuf);
/* copy stuff from adapter to payload */
gst_adapter_copy (rtpmp2tpay->adapter, payload, 0, avail);
GST_BUFFER_TIMESTAMP (outbuf) = rtpmp2tpay->first_ts;
GST_BUFFER_DURATION (outbuf) = rtpmp2tpay->duration;
GST_DEBUG_OBJECT (rtpmp2tpay, "pushing buffer of size %d",
GST_BUFFER_SIZE (outbuf));
ret = gst_basertppayload_push (GST_BASE_RTP_PAYLOAD (rtpmp2tpay), outbuf);
/* flush the adapter content */
gst_adapter_flush (rtpmp2tpay->adapter, avail);
return ret;
}
static int
gst_ffmpeg_pipe_read (URLContext * h, unsigned char *buf, int size)
{
GstFFMpegPipe *ffpipe;
guint available;
ffpipe = (GstFFMpegPipe *) h->priv_data;
GST_LOG ("requested size %d", size);
GST_FFMPEG_PIPE_MUTEX_LOCK (ffpipe);
GST_LOG ("requested size %d", size);
while ((available = gst_adapter_available (ffpipe->adapter)) < size
&& !ffpipe->eos) {
GST_DEBUG ("Available:%d, requested:%d", available, size);
ffpipe->needed = size;
GST_FFMPEG_PIPE_SIGNAL (ffpipe);
GST_FFMPEG_PIPE_WAIT (ffpipe);
}
size = MIN (available, size);
if (size) {
GST_LOG ("Getting %d bytes", size);
gst_adapter_copy (ffpipe->adapter, buf, 0, size);
gst_adapter_flush (ffpipe->adapter, size);
GST_LOG ("%d bytes left in adapter",
gst_adapter_available (ffpipe->adapter));
ffpipe->needed = 0;
}
GST_FFMPEG_PIPE_MUTEX_UNLOCK (ffpipe);
return size;
}
static GstFlowReturn
gst_inter_audio_sink_render (GstBaseSink * sink, GstBuffer * buffer)
{
GstInterAudioSink *interaudiosink = GST_INTER_AUDIO_SINK (sink);
guint n, bpf;
guint64 period_time, buffer_time;
guint64 period_samples, buffer_samples;
GST_DEBUG_OBJECT (interaudiosink, "render %" G_GSIZE_FORMAT,
gst_buffer_get_size (buffer));
bpf = interaudiosink->info.bpf;
g_mutex_lock (&interaudiosink->surface->mutex);
buffer_time = interaudiosink->surface->audio_buffer_time;
period_time = interaudiosink->surface->audio_period_time;
if (buffer_time < period_time) {
GST_ERROR_OBJECT (interaudiosink,
"Buffer time smaller than period time (%" GST_TIME_FORMAT " < %"
GST_TIME_FORMAT ")", GST_TIME_ARGS (buffer_time),
GST_TIME_ARGS (period_time));
g_mutex_unlock (&interaudiosink->surface->mutex);
return GST_FLOW_ERROR;
}
buffer_samples =
gst_util_uint64_scale (buffer_time, interaudiosink->info.rate,
GST_SECOND);
period_samples =
gst_util_uint64_scale (period_time, interaudiosink->info.rate,
GST_SECOND);
n = gst_adapter_available (interaudiosink->surface->audio_adapter) / bpf;
while (n > buffer_samples) {
GST_DEBUG_OBJECT (interaudiosink, "flushing %" GST_TIME_FORMAT,
GST_TIME_ARGS (period_time));
gst_adapter_flush (interaudiosink->surface->audio_adapter,
period_samples * bpf);
n -= period_samples;
}
n = gst_adapter_available (interaudiosink->input_adapter);
if (period_samples * bpf > gst_buffer_get_size (buffer) + n) {
gst_adapter_push (interaudiosink->input_adapter, gst_buffer_ref (buffer));
} else {
GstBuffer *tmp;
if (n > 0) {
tmp = gst_adapter_take_buffer (interaudiosink->input_adapter, n);
gst_adapter_push (interaudiosink->surface->audio_adapter, tmp);
}
gst_adapter_push (interaudiosink->surface->audio_adapter,
gst_buffer_ref (buffer));
}
g_mutex_unlock (&interaudiosink->surface->mutex);
return GST_FLOW_OK;
}
static GstFlowReturn
gst_rtp_mpv_pay_flush (GstRTPMPVPay * rtpmpvpay, GstClockTime timestamp,
GstClockTime duration)
{
GstBuffer *outbuf;
GstFlowReturn ret;
guint avail;
guint8 *payload;
gint packet_size;
gint payload_size;
avail = gst_adapter_available (rtpmpvpay->adapter);
packet_size = gst_rtp_buffer_calc_packet_len (4 + avail, 0, 0);
/* check for the maximum size of the rtp buffer */
if (packet_size > GST_BASE_RTP_PAYLOAD_MTU (rtpmpvpay)) {
payload_size =
GST_BASE_RTP_PAYLOAD_MTU (rtpmpvpay) -
gst_rtp_buffer_calc_packet_len (4, 0, 0);
} else {
payload_size = avail;
}
outbuf = gst_rtp_buffer_new_allocate (4 + payload_size, 0, 0);
/* enable MPEG Video-specific header
*
* 0 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | MBZ |T| TR | |N|S|B|E| P | | BFC | | FFC |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* AN FBV FFV
*/
payload = gst_rtp_buffer_get_payload (outbuf);
/* fill in the MPEG Video-specific header */
memset (payload, 0x0, 4);
/* copy stuff from adapter to payload */
gst_adapter_copy (rtpmpvpay->adapter, payload + 4, 0, payload_size);
GST_BUFFER_TIMESTAMP (outbuf) = rtpmpvpay->first_ts;
GST_BUFFER_DURATION (outbuf) = rtpmpvpay->duration;
GST_DEBUG_OBJECT (rtpmpvpay, "pushing buffer of size %d",
GST_BUFFER_SIZE (outbuf));
ret = gst_basertppayload_push (GST_BASE_RTP_PAYLOAD (rtpmpvpay), outbuf);
gst_adapter_flush (rtpmpvpay->adapter, payload_size);
/* update the timestamp and duration */
rtpmpvpay->first_ts = timestamp;
rtpmpvpay->duration = duration;
/* check if there is enough data for another rtp buffer */
avail = gst_adapter_available (rtpmpvpay->adapter);
packet_size = gst_rtp_buffer_calc_packet_len (4 + avail, 0, 0);
if (packet_size >= GST_BASE_RTP_PAYLOAD_MTU (rtpmpvpay) && ret == GST_FLOW_OK) {
GST_DEBUG_OBJECT (rtpmpvpay, "Have enough data for another rtp packet");
ret = gst_rtp_mpv_pay_flush (rtpmpvpay, timestamp, duration);
}
return ret;
}
static void
chunk_flush (GstAdapter *adapter, Chunk *chunk)
{
g_return_if_fail (chunk->available == chunk->length);
gst_adapter_flush (adapter, chunk->length);
chunk_clear (chunk);
}
/*
把 buffer 拿出来
*/
guint8 *
gst_adapter_take (GstAdapter * adapter, guint nbytes)
{
cdata = gst_adapter_peek (adapter, nbytes);
data = g_malloc (nbytes);
memcpy (data, cdata, nbytes);
gst_adapter_flush (adapter, nbytes);
}
static gboolean
theora_enc_read_multipass_cache (GstTheoraEnc * enc)
{
GstBuffer *cache_buf;
const guint8 *cache_data;
gsize bytes_read = 0;
gssize bytes_consumed = 0;
GIOStatus stat = G_IO_STATUS_NORMAL;
gboolean done = FALSE;
while (!done) {
if (gst_adapter_available (enc->multipass_cache_adapter) == 0) {
GstMapInfo minfo;
cache_buf = gst_buffer_new_allocate (NULL, 512, NULL);
gst_buffer_map (cache_buf, &minfo, GST_MAP_WRITE);
stat = g_io_channel_read_chars (enc->multipass_cache_fd,
(gchar *) minfo.data, minfo.size, &bytes_read, NULL);
if (bytes_read <= 0) {
gst_buffer_unmap (cache_buf, &minfo);
gst_buffer_unref (cache_buf);
break;
} else {
gst_buffer_unmap (cache_buf, &minfo);
gst_buffer_resize (cache_buf, 0, bytes_read);
gst_adapter_push (enc->multipass_cache_adapter, cache_buf);
}
}
if (gst_adapter_available (enc->multipass_cache_adapter) == 0)
break;
bytes_read =
MIN (gst_adapter_available (enc->multipass_cache_adapter), 512);
cache_data = gst_adapter_map (enc->multipass_cache_adapter, bytes_read);
bytes_consumed =
th_encode_ctl (enc->encoder, TH_ENCCTL_2PASS_IN, (guint8 *) cache_data,
bytes_read);
gst_adapter_unmap (enc->multipass_cache_adapter);
done = bytes_consumed <= 0;
if (bytes_consumed > 0)
gst_adapter_flush (enc->multipass_cache_adapter, bytes_consumed);
}
if (stat == G_IO_STATUS_ERROR || (stat == G_IO_STATUS_EOF && bytes_read == 0)
|| bytes_consumed < 0) {
GST_ELEMENT_ERROR (enc, RESOURCE, READ, (NULL),
("Failed to read multipass cache file"));
return FALSE;
}
return TRUE;
}
static int mpegts_demuxer_read_packet(void *opaque, uint8_t *buffer, int size)
{
MpegTSDemuxer *demuxer = MPEGTS_DEMUXER(opaque);
int result = 0;
g_mutex_lock(&demuxer->lock);
gint available = gst_adapter_available(demuxer->sink_adapter);
while (available < demuxer->offset + size &&
!demuxer->is_eos && !demuxer->is_flushing && demuxer->is_reading)
{
if (demuxer->adapter_limit_type == UNLIMITED &&
demuxer->adapter_limit_size - LIMIT_STEP < demuxer->offset + size)
{
demuxer->adapter_limit_size += LIMIT_STEP;
g_cond_signal(&demuxer->del_cond);
}
else
g_cond_wait(&demuxer->add_cond, &demuxer->lock);
available = gst_adapter_available(demuxer->sink_adapter);
}
if (demuxer->is_reading && !demuxer->is_flushing)
{
if (demuxer->is_eos && available <= size) {
demuxer->is_last_buffer_send = TRUE; // Last buffer
size = available;
}
if (size > 0)
{
gst_adapter_copy(demuxer->sink_adapter, buffer, demuxer->offset, size);
if (demuxer->flush_adapter)
gst_adapter_flush(demuxer->sink_adapter, size);
else
demuxer->offset += size;
g_cond_signal(&demuxer->del_cond);
result = size;
#ifdef FAKE_ERROR
demuxer->read_bytes += size;
#endif
}
}
else
result = 0; // No more data
g_mutex_unlock(&demuxer->lock);
#ifdef DEBUG_OUTPUT
if (result <= 0)
g_print("MpegTS: read_packet result = %d, is_eos=%s, is_reading=%s, is_flushing=%s\n",
result, BV(demuxer->is_eos), BV(demuxer->is_reading), BV(demuxer->is_flushing));
#endif
return result;
}
static GstFlowReturn
gst_real_audio_demux_parse_data (GstRealAudioDemux * demux)
{
GstFlowReturn ret = GST_FLOW_OK;
guint avail, unit_size;
avail = gst_adapter_available (demux->adapter);
if (demux->packet_size > 0)
unit_size = demux->packet_size;
else
unit_size = avail & 0xfffffff0; /* round down to next multiple of 16 */
GST_LOG_OBJECT (demux, "available = %u, unit_size = %u", avail, unit_size);
while (ret == GST_FLOW_OK && unit_size > 0 && avail >= unit_size) {
GstClockTime ts;
const guint8 *data;
GstBuffer *buf = NULL;
buf = gst_buffer_new_and_alloc (unit_size);
gst_buffer_set_caps (buf, GST_PAD_CAPS (demux->srcpad));
data = gst_adapter_peek (demux->adapter, unit_size);
memcpy (GST_BUFFER_DATA (buf), data, unit_size);
gst_adapter_flush (demux->adapter, unit_size);
avail -= unit_size;
if (demux->need_newsegment) {
gst_pad_push_event (demux->srcpad,
gst_event_new_new_segment_full (FALSE, demux->segment.rate,
demux->segment.applied_rate, GST_FORMAT_TIME,
demux->segment.start, demux->segment.stop, demux->segment.time));
demux->need_newsegment = FALSE;
}
if (demux->pending_tags) {
gst_element_found_tags_for_pad (GST_ELEMENT (demux), demux->srcpad,
demux->pending_tags);
demux->pending_tags = NULL;
}
if (demux->fourcc == GST_RM_AUD_DNET) {
buf = gst_rm_utils_descramble_dnet_buffer (buf);
}
ts = gst_real_demux_get_timestamp_from_offset (demux, demux->offset);
GST_BUFFER_TIMESTAMP (buf) = ts;
gst_segment_set_last_stop (&demux->segment, GST_FORMAT_TIME, ts);
ret = gst_pad_push (demux->srcpad, buf);
}
return ret;
}
static GstFlowReturn
gst_rtp_sbc_pay_flush_buffers (GstRtpSBCPay * sbcpay)
{
GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
guint available;
guint max_payload;
GstBuffer *outbuf;
guint8 *payload_data;
guint frame_count;
guint payload_length;
struct rtp_payload *payload;
if (sbcpay->frame_length == 0) {
GST_ERROR_OBJECT (sbcpay, "Frame length is 0");
return GST_FLOW_ERROR;
}
available = gst_adapter_available (sbcpay->adapter);
max_payload =
gst_rtp_buffer_calc_payload_len (GST_RTP_BASE_PAYLOAD_MTU (sbcpay) -
RTP_SBC_PAYLOAD_HEADER_SIZE, 0, 0);
max_payload = MIN (max_payload, available);
frame_count = max_payload / sbcpay->frame_length;
payload_length = frame_count * sbcpay->frame_length;
if (payload_length == 0) /* Nothing to send */
return GST_FLOW_OK;
outbuf = gst_rtp_buffer_new_allocate (payload_length +
RTP_SBC_PAYLOAD_HEADER_SIZE, 0, 0);
/* get payload */
gst_rtp_buffer_map (outbuf, GST_MAP_WRITE, &rtp);
gst_rtp_buffer_set_payload_type (&rtp, GST_RTP_BASE_PAYLOAD_PT (sbcpay));
/* write header and copy data into payload */
payload_data = gst_rtp_buffer_get_payload (&rtp);
payload = (struct rtp_payload *) payload_data;
memset (payload, 0, sizeof (struct rtp_payload));
payload->frame_count = frame_count;
gst_adapter_copy (sbcpay->adapter, payload_data +
RTP_SBC_PAYLOAD_HEADER_SIZE, 0, payload_length);
gst_rtp_buffer_unmap (&rtp);
gst_adapter_flush (sbcpay->adapter, payload_length);
/* FIXME: what about duration? */
GST_BUFFER_PTS (outbuf) = sbcpay->timestamp;
GST_DEBUG_OBJECT (sbcpay, "Pushing %d bytes", payload_length);
return gst_rtp_base_payload_push (GST_RTP_BASE_PAYLOAD (sbcpay), outbuf);
}
static GstFlowReturn
gst_rtp_mpv_pay_flush (GstRTPMPVPay * rtpmpvpay)
{
GstBuffer *outbuf;
GstFlowReturn ret;
guint avail;
guint8 *payload;
avail = gst_adapter_available (rtpmpvpay->adapter);
ret = GST_FLOW_OK;
while (avail > 0) {
guint towrite;
guint packet_len;
guint payload_len;
packet_len = gst_rtp_buffer_calc_packet_len (avail, 4, 0);
towrite = MIN (packet_len, GST_BASE_RTP_PAYLOAD_MTU (rtpmpvpay));
payload_len = gst_rtp_buffer_calc_payload_len (towrite, 4, 0);
outbuf = gst_rtp_buffer_new_allocate (payload_len, 4, 0);
payload = gst_rtp_buffer_get_payload (outbuf);
/* enable MPEG Video-specific header
*
* 0 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* | MBZ |T| TR | |N|S|B|E| P | | BFC | | FFC |
* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* AN FBV FFV
*/
/* fill in the MPEG Video-specific header
* data is set to 0x0 here
*/
memset (payload, 0x0, 4);
gst_adapter_copy (rtpmpvpay->adapter, payload + 4, 0, payload_len);
gst_adapter_flush (rtpmpvpay->adapter, payload_len);
avail -= payload_len;
gst_rtp_buffer_set_marker (outbuf, avail == 0);
GST_BUFFER_TIMESTAMP (outbuf) = rtpmpvpay->first_ts;
ret = gst_basertppayload_push (GST_BASE_RTP_PAYLOAD (rtpmpvpay), outbuf);
}
return ret;
}
static MetadataParsingReturn
metadataparse_jpeg_iptc (JpegParseData * jpeg_data, guint8 ** buf,
guint32 * bufsize, guint8 ** next_start, guint32 * next_size)
{
int ret;
ret = metadataparse_util_hold_chunk (&jpeg_data->read, buf,
bufsize, next_start, next_size, jpeg_data->iptc_adapter);
if (ret == META_PARSING_DONE) {
const guint8 *buf;
guint32 size;
unsigned int iptc_len;
int res;
jpeg_data->state = JPEG_PARSE_READING;
size = gst_adapter_available (*jpeg_data->iptc_adapter);
buf = gst_adapter_peek (*jpeg_data->iptc_adapter, size);
/* FIXME: currently we are throwing away others PhotoShop data */
res = iptc_jpeg_ps3_find_iptc (buf, size, &iptc_len);
if (res < 0) {
/* error */
ret = META_PARSING_ERROR;
} else if (res == 0) {
/* no iptc data found */
gst_adapter_clear (*jpeg_data->iptc_adapter);
} else {
gst_adapter_flush (*jpeg_data->iptc_adapter, res);
size = gst_adapter_available (*jpeg_data->iptc_adapter);
if (size > iptc_len) {
GstBuffer *buf;
buf = gst_adapter_take_buffer (*jpeg_data->iptc_adapter, iptc_len);
gst_adapter_clear (*jpeg_data->iptc_adapter);
gst_adapter_push (*jpeg_data->iptc_adapter, buf);
}
}
/* if there is a second Iptc chunk in the file it will be jumped */
jpeg_data->iptc_adapter = NULL;
}
return ret;
}
void
gst_base_video_decoder_lost_sync (GstBaseVideoDecoder * base_video_decoder)
{
g_return_if_fail (GST_IS_BASE_VIDEO_DECODER (base_video_decoder));
GST_DEBUG ("lost_sync");
if (gst_adapter_available (base_video_decoder->input_adapter) >= 1) {
gst_adapter_flush (base_video_decoder->input_adapter, 1);
}
base_video_decoder->have_sync = FALSE;
}
void
gst_base_video_parse_lost_sync (GstBaseVideoParse * base_video_parse)
{
g_return_if_fail (GST_IS_BASE_VIDEO_PARSE (base_video_parse));
GST_DEBUG ("lost_sync");
if (gst_adapter_available (base_video_parse->input_adapter) >= 1) {
gst_adapter_flush (base_video_parse->input_adapter, 1);
}
base_video_parse->have_sync = FALSE;
}
static void copyGStreamerBuffersToAudioChannel(GstAdapter* adapter, AudioBus* bus , int channelNumber, size_t framesToProcess)
{
if (!gst_adapter_available(adapter)) {
bus->zero();
return;
}
size_t bytes = framesToProcess * sizeof(float);
if (gst_adapter_available(adapter) >= bytes) {
gst_adapter_copy(adapter, bus->channel(channelNumber)->mutableData(), 0, bytes);
gst_adapter_flush(adapter, bytes);
}
}
static GstFlowReturn sbc_enc_chain(GstPad *pad, GstBuffer *buffer)
{
GstSbcEnc *enc = GST_SBC_ENC(gst_pad_get_parent(pad));
GstAdapter *adapter = enc->adapter;
GstFlowReturn res = GST_FLOW_OK;
gst_adapter_push(adapter, buffer);
while (gst_adapter_available(adapter) >= enc->codesize &&
res == GST_FLOW_OK) {
GstBuffer *output;
GstCaps *caps;
const guint8 *data;
gint consumed;
caps = GST_PAD_CAPS(enc->srcpad);
res = gst_pad_alloc_buffer_and_set_caps(enc->srcpad,
GST_BUFFER_OFFSET_NONE,
enc->frame_length, caps,
&output);
if (res != GST_FLOW_OK)
goto done;
data = gst_adapter_peek(adapter, enc->codesize);
consumed = sbc_encode(&enc->sbc, (gpointer) data,
enc->codesize,
GST_BUFFER_DATA(output),
GST_BUFFER_SIZE(output), NULL);
if (consumed <= 0) {
GST_DEBUG_OBJECT(enc, "comsumed < 0, codesize: %d",
enc->codesize);
break;
}
gst_adapter_flush(adapter, consumed);
GST_BUFFER_TIMESTAMP(output) = GST_BUFFER_TIMESTAMP(buffer);
/* we have only 1 frame */
GST_BUFFER_DURATION(output) = enc->frame_duration;
res = gst_pad_push(enc->srcpad, output);
if (res != GST_FLOW_OK)
goto done;
}
done:
gst_object_unref(enc);
return res;
}
static GstFlowReturn
gst_rtp_mp4v_pay_flush (GstRtpMP4VPay * rtpmp4vpay)
{
guint avail;
GstBuffer *outbuf;
GstFlowReturn ret;
/* the data available in the adapter is either smaller
* than the MTU or bigger. In the case it is smaller, the complete
* adapter contents can be put in one packet. In the case the
* adapter has more than one MTU, we need to split the MP4V data
* over multiple packets. */
avail = gst_adapter_available (rtpmp4vpay->adapter);
ret = GST_FLOW_OK;
while (avail > 0) {
guint towrite;
guint8 *payload;
guint payload_len;
guint packet_len;
/* this will be the total lenght of the packet */
packet_len = gst_rtp_buffer_calc_packet_len (avail, 0, 0);
/* fill one MTU or all available bytes */
towrite = MIN (packet_len, GST_BASE_RTP_PAYLOAD_MTU (rtpmp4vpay));
/* this is the payload length */
payload_len = gst_rtp_buffer_calc_payload_len (towrite, 0, 0);
/* create buffer to hold the payload */
outbuf = gst_rtp_buffer_new_allocate (payload_len, 0, 0);
/* copy payload */
payload = gst_rtp_buffer_get_payload (outbuf);
gst_adapter_copy (rtpmp4vpay->adapter, payload, 0, payload_len);
gst_adapter_flush (rtpmp4vpay->adapter, payload_len);
avail -= payload_len;
gst_rtp_buffer_set_marker (outbuf, avail == 0);
GST_BUFFER_TIMESTAMP (outbuf) = rtpmp4vpay->first_timestamp;
ret = gst_basertppayload_push (GST_BASE_RTP_PAYLOAD (rtpmp4vpay), outbuf);
}
return ret;
}
long
AudioStream::read_bytes (void *data, long length)
{
gssize len = gst_adapter_available (adapter);
if (len < length)
length = len;
GST_LOG ("Reading %d bytes from adapter", (int) length);
gst_adapter_copy (adapter, data, 0, length);
gst_adapter_flush (adapter, length);
return length;
}
static void
chunk_skip (GstAdapter *adapter, Chunk *chunk, guint size)
{
g_return_if_fail (size <= chunk->available);
chunk->length -= size;
chunk->available -= size;
gst_adapter_flush (adapter, size);
if (chunk->available) {
chunk->data = gst_adapter_peek (adapter, chunk->available);
g_assert (chunk->data);
} else {
chunk->data = NULL;
}
GST_LOG ("skipped %u bytes, %u of %u still available\n", size,
chunk->available, chunk->length);
}
static GstFlowReturn gst_rtp_sbc_pay_flush_buffers(GstRtpSBCPay *sbcpay)
{
guint available;
guint max_payload;
GstBuffer *outbuf;
guint8 *payload_data;
guint frame_count;
guint payload_length;
struct rtp_payload *payload;
if (sbcpay->frame_length == 0) {
GST_ERROR_OBJECT(sbcpay, "Frame length is 0");
return GST_FLOW_ERROR;
}
available = gst_adapter_available(sbcpay->adapter);
max_payload = gst_rtp_buffer_calc_payload_len(
GST_BASE_RTP_PAYLOAD_MTU(sbcpay) - RTP_SBC_PAYLOAD_HEADER_SIZE,
0, 0);
max_payload = MIN(max_payload, available);
frame_count = max_payload / sbcpay->frame_length;
payload_length = frame_count * sbcpay->frame_length;
if (payload_length == 0) /* Nothing to send */
return GST_FLOW_OK;
outbuf = gst_rtp_buffer_new_allocate(payload_length +
RTP_SBC_PAYLOAD_HEADER_SIZE, 0, 0);
gst_rtp_buffer_set_payload_type(outbuf,
GST_BASE_RTP_PAYLOAD_PT(sbcpay));
payload_data = gst_rtp_buffer_get_payload(outbuf);
payload = (struct rtp_payload *) payload_data;
memset(payload, 0, sizeof(struct rtp_payload));
payload->frame_count = frame_count;
gst_adapter_copy(sbcpay->adapter, payload_data +
RTP_SBC_PAYLOAD_HEADER_SIZE, 0, payload_length);
gst_adapter_flush(sbcpay->adapter, payload_length);
GST_BUFFER_TIMESTAMP(outbuf) = sbcpay->timestamp;
GST_DEBUG_OBJECT(sbcpay, "Pushing %d bytes", payload_length);
return gst_basertppayload_push(GST_BASE_RTP_PAYLOAD(sbcpay), outbuf);
}
static gboolean
get_next_chunk (GstAdapter *adapter, Chunk *chunk)
{
const guint8 *data;
guint length;
data = gst_adapter_peek (adapter, 8);
if (!data) return FALSE;
length = GST_READ_UINT32_BE (data + 4);
chunk->fourcc = GST_READ_UINT32_LE (data);
chunk->length = length;
gst_adapter_flush (adapter, 8);
chunk->data = gst_adapter_peek (adapter, gst_adapter_available_fast (adapter));
chunk->available = gst_adapter_available_fast (adapter);
return TRUE;
}
HRESULT
Output::RenderAudioSamples (bool preroll)
{
uint32_t samplesWritten;
// guint64 samplesToWrite;
if (decklinksink->stop) {
GST_DEBUG ("decklinksink->stop set TRUE!");
decklinksink->output->BeginAudioPreroll ();
// running = true;
} else {
gconstpointer data;
int n;
g_mutex_lock (&decklinksink->audio_mutex);
n = gst_adapter_available (decklinksink->audio_adapter);
if (n > 0) {
data = gst_adapter_map (decklinksink->audio_adapter, n);
decklinksink->output->ScheduleAudioSamples ((void *) data, n / 4,
0, 0, &samplesWritten);
gst_adapter_unmap (decklinksink->audio_adapter);
gst_adapter_flush (decklinksink->audio_adapter, samplesWritten * 4);
GST_DEBUG ("wrote %d samples, %d available", samplesWritten, n / 4);
g_cond_signal (&decklinksink->audio_cond);
} else {
if (decklinksink->audio_eos) {
GstMessage *message;
message = gst_message_new_eos (GST_OBJECT_CAST (decklinksink));
gst_message_set_seqnum (message, decklinksink->audio_seqnum);
gst_element_post_message (GST_ELEMENT_CAST (decklinksink), message);
}
}
g_mutex_unlock (&decklinksink->audio_mutex);
}
GST_DEBUG ("RenderAudioSamples");
return S_OK;
}
static gboolean
scope_parser_buffer_probe(GstPad *pad, GstBuffer *buffer, gpointer user_data)
{
ScopeParser *parser = (ScopeParser *)user_data;
guint available = gst_adapter_available(parser->adapter);
// this sucks
if(available > SCOPE_SIZE) {
gst_adapter_flush(parser->adapter, available - 30000);
}
if(buffer != NULL) {
gst_buffer_ref(buffer);
gst_adapter_push(parser->adapter, buffer);
}
return TRUE;
}
static void
gst_aiff_parse_ignore_chunk (GstAiffParse * aiff, GstBuffer * buf, guint32 tag,
guint32 size)
{
guint flush;
if (aiff->streaming) {
if (!gst_aiff_parse_peek_chunk (aiff, &tag, &size))
return;
}
GST_DEBUG_OBJECT (aiff, "Ignoring tag %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (tag));
flush = 8 + ((size + 1) & ~1);
aiff->offset += flush;
if (aiff->streaming) {
gst_adapter_flush (aiff->adapter, flush);
} else {
gst_buffer_unref (buf);
}
}
static GstFlowReturn
gst_inter_audio_sink_render (GstBaseSink * sink, GstBuffer * buffer)
{
GstInterAudioSink *interaudiosink = GST_INTER_AUDIO_SINK (sink);
int n;
GST_DEBUG ("render %d", GST_BUFFER_SIZE (buffer));
g_mutex_lock (interaudiosink->surface->mutex);
n = gst_adapter_available (interaudiosink->surface->audio_adapter) / 4;
if (n > (800 * 2 * 2)) {
GST_INFO ("flushing 800 samples");
gst_adapter_flush (interaudiosink->surface->audio_adapter, 800 * 4);
n -= 800;
}
gst_adapter_push (interaudiosink->surface->audio_adapter,
gst_buffer_ref (buffer));
g_mutex_unlock (interaudiosink->surface->mutex);
return GST_FLOW_OK;
}
