556 lines
17 KiB
C
556 lines
17 KiB
C
/* GStreamer
|
|
* Copyright (C) 2023 <[email protected]>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "gstamladapterpipe.h"
|
|
#include "aml_defs.h"
|
|
|
|
GST_DEBUG_CATEGORY_EXTERN(gst_amlhwdmx_ap_debug);
|
|
#ifdef GST_CAT_DEFAULT
|
|
#undef GST_CAT_DEFAULT
|
|
#endif
|
|
#define GST_CAT_DEFAULT gst_amlhwdmx_ap_debug
|
|
|
|
typedef struct _GstClearAdapter GstClearAdapter;
|
|
typedef struct _GstSecureAdapter GstSecureAdapter;
|
|
|
|
struct _GstClearAdapter
|
|
{
|
|
/* adpater collecting clear data */
|
|
GstAdapter *adapter;
|
|
guint prob_peek_offset;
|
|
};
|
|
|
|
struct _GstSecureAdapter
|
|
{
|
|
/* adpater collecting secure dma buf */
|
|
GstQueueArray *sec_buf_q;
|
|
guint prob_peek_idx;
|
|
};
|
|
|
|
struct _GstAdapterPipe
|
|
{
|
|
GstAdapterPipeDataType type;
|
|
/* lock for syncing */
|
|
GMutex tlock;
|
|
/* with TLOCK */
|
|
/* signals counterpart thread to have a look */
|
|
GCond cond;
|
|
/* seen eos */
|
|
gboolean eos;
|
|
gboolean secure;
|
|
gboolean unlimit;
|
|
/* seen flushing */
|
|
gboolean flushing;
|
|
/* flowreturn obtained by src task */
|
|
GstFlowReturn srcresult;
|
|
GstAdapterPipeStatus status;
|
|
union
|
|
{
|
|
GstClearAdapter clear_ap;
|
|
GstSecureAdapter secure_ap;
|
|
} s;
|
|
};
|
|
|
|
GstFlowReturn gst_amladapterpipe_init(GstAdapterPipe *pipe, GstAdapterPipeDataType type, gboolean is_secure, gboolean is_unlimit);
|
|
static GstFlowReturn gst_amladapterpipe_dispose(GstAdapterPipe *pipe);
|
|
static GstFlowReturn gst_amladapterpipe_clear_unlock(GstAdapterPipe *pipe);
|
|
static GstFlowReturn gst_amladapterpipe_push_uncheck_unlock(GstAdapterPipe *pipe, GstBuffer *buffer);
|
|
static GstFlowReturn gst_amladapterpipe_pop_uncheck_unlock(GstAdapterPipe *pipe, GstBuffer **buffer);
|
|
#if 0
|
|
static gboolean gst_amladapterpipe_overrun_unlock(GstAdapterPipe *pipe);
|
|
static gboolean gst_amladapterpipe_underrun_unlock(GstAdapterPipe *pipe);
|
|
#endif
|
|
|
|
/* private interfaces */
|
|
GstFlowReturn gst_amladapterpipe_init(GstAdapterPipe *pipe, GstAdapterPipeDataType type, gboolean is_secure, gboolean is_unlimit)
|
|
{
|
|
g_mutex_init(&pipe->tlock);
|
|
g_cond_init(&pipe->cond);
|
|
pipe->eos = FALSE;
|
|
pipe->type = type;
|
|
pipe->secure = is_secure;
|
|
pipe->unlimit = is_unlimit;
|
|
pipe->srcresult = GST_FLOW_OK;
|
|
|
|
pipe->status.pushed_size = 0;
|
|
pipe->status.poped_size = 0;
|
|
|
|
pipe->status.low_num = SEC_BUF_QUEUE_MIN_SIZE;
|
|
pipe->status.max_num = SEC_BUF_QUEUE_MAX_SIZE;
|
|
pipe->status.needed_num = SEC_BUF_QUEUE_NEEDED_SIZE;
|
|
|
|
pipe->status.low_size = LOW_BUFFER_SIZE;
|
|
pipe->status.max_size = MAX_BUFFER_SIZE;
|
|
pipe->status.needed_size = LOW_BUFFER_SIZE;
|
|
pipe->status.cur_size = 0;
|
|
|
|
if (pipe->secure)
|
|
{
|
|
pipe->s.secure_ap.sec_buf_q = gst_queue_array_new(SEC_BUF_QUEUE_MAX_SIZE);
|
|
g_return_val_if_fail(pipe->s.secure_ap.sec_buf_q, GST_FLOW_ERROR);
|
|
|
|
pipe->status.cur_num = 0;
|
|
pipe->status.pushed_num = 0;
|
|
pipe->status.poped_num = 0;
|
|
|
|
pipe->s.secure_ap.prob_peek_idx = 0;
|
|
|
|
/* unset clear assert for secure scene */
|
|
pipe->status.low_size = 0;
|
|
pipe->status.max_size = -1;
|
|
pipe->status.needed_size = 0;
|
|
}
|
|
else
|
|
{
|
|
pipe->s.clear_ap.adapter = gst_adapter_new();
|
|
g_return_val_if_fail(pipe->s.clear_ap.adapter, GST_FLOW_ERROR);
|
|
|
|
pipe->status.cur_num = (pipe->status.low_num + pipe->status.max_num) / 2;
|
|
pipe->status.pushed_num = pipe->status.cur_num;
|
|
pipe->status.poped_num = pipe->status.cur_num;
|
|
|
|
pipe->s.clear_ap.prob_peek_offset = 0;
|
|
|
|
/* unset secure assert for clear scene */
|
|
pipe->status.low_num = 0;
|
|
pipe->status.max_num = -1;
|
|
pipe->status.needed_num = 0;
|
|
}
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_dispose(GstAdapterPipe *pipe)
|
|
{
|
|
if (pipe->s.clear_ap.adapter)
|
|
{
|
|
g_object_unref(G_OBJECT(pipe->s.clear_ap.adapter));
|
|
pipe->s.clear_ap.adapter = NULL;
|
|
}
|
|
|
|
if (pipe->s.secure_ap.sec_buf_q)
|
|
{
|
|
gst_queue_array_free(pipe->s.secure_ap.sec_buf_q);
|
|
pipe->s.secure_ap.sec_buf_q = NULL;
|
|
}
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
static GstFlowReturn gst_amladapterpipe_clear_unlock(GstAdapterPipe *pipe)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
if (pipe->secure)
|
|
{
|
|
if (pipe->s.secure_ap.sec_buf_q)
|
|
{
|
|
GstMiniObject *obj;
|
|
while ((obj = gst_queue_array_pop_head(pipe->s.secure_ap.sec_buf_q)))
|
|
gst_mini_object_unref(obj);
|
|
}
|
|
|
|
pipe->status.cur_num = 0;
|
|
pipe->status.pushed_num = 0;
|
|
pipe->status.poped_num = 0;
|
|
|
|
pipe->s.secure_ap.prob_peek_idx = 0;
|
|
}
|
|
else
|
|
{
|
|
if (pipe->s.clear_ap.adapter)
|
|
gst_adapter_clear(pipe->s.clear_ap.adapter);
|
|
|
|
pipe->s.clear_ap.prob_peek_offset = 0;
|
|
}
|
|
|
|
pipe->status.cur_size = 0;
|
|
pipe->status.pushed_size = 0;
|
|
pipe->status.poped_size = 0;
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
#if 0
|
|
static gboolean gst_amladapterpipe_overrun_unlock(GstAdapterPipe *pipe)
|
|
{
|
|
if (pipe->status.cur_num > pipe->status.max_num || pipe->status.cur_size > pipe->status.max_size)
|
|
{
|
|
GST_DEBUG("pipe:%p, type:%d, overrun, [status.cur_num:%d, status.max_num:%d], [status.cur_size:%d, status.max_size:%d]",
|
|
pipe, pipe->type, pipe->status.cur_num, pipe->status.max_num, pipe->status.cur_size, pipe->status.max_size);
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean gst_amladapterpipe_underrun_unlock(GstAdapterPipe *pipe)
|
|
{
|
|
if (pipe->status.cur_num < pipe->status.needed_num || pipe->status.cur_size < pipe->status.needed_size)
|
|
{
|
|
GST_DEBUG("pipe:%p, type:%d, overrun, [status.cur_num:%d, status.needed_num:%d], [status.cur_size:%d, status.needed_size:%d]",
|
|
pipe, pipe->type, pipe->status.cur_num, pipe->status.needed_num, pipe->status.cur_size, pipe->status.needed_size);
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
static GstFlowReturn gst_amladapterpipe_push_uncheck_unlock(GstAdapterPipe *pipe, GstBuffer *buffer)
|
|
{
|
|
if (pipe->secure)
|
|
{
|
|
gst_queue_array_push_tail(pipe->s.secure_ap.sec_buf_q, buffer);
|
|
pipe->status.cur_num++;
|
|
pipe->status.pushed_num++;
|
|
}
|
|
else
|
|
gst_adapter_push(pipe->s.clear_ap.adapter, buffer);
|
|
|
|
pipe->status.cur_size += gst_buffer_get_size(buffer);
|
|
pipe->status.pushed_size += gst_buffer_get_size(buffer);
|
|
|
|
GST_TRACE("pipe:%p, type:%d, pushed in buffer %p, status.cur_num:%d, status.cur_size:%d", pipe, pipe->type, buffer, pipe->status.cur_num, pipe->status.cur_size);
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
static GstFlowReturn gst_amladapterpipe_pop_uncheck_unlock(GstAdapterPipe *pipe, GstBuffer **buffer)
|
|
{
|
|
GstFlowReturn ret;
|
|
|
|
ret = GST_FLOW_OK;
|
|
|
|
if (pipe->secure)
|
|
{
|
|
*buffer = (GstBuffer *)gst_queue_array_pop_head(pipe->s.secure_ap.sec_buf_q);
|
|
}
|
|
else
|
|
{
|
|
*buffer = gst_adapter_take_buffer(pipe->s.clear_ap.adapter, BUFFER_SIZE);
|
|
}
|
|
|
|
if (*buffer == NULL)
|
|
{
|
|
ret = GST_FLOW_AMLAP_EMPTY;
|
|
}
|
|
else
|
|
{
|
|
if (pipe->secure)
|
|
{
|
|
pipe->status.cur_num--;
|
|
pipe->status.poped_num++;
|
|
}
|
|
pipe->status.cur_size -= gst_buffer_get_size(*buffer);
|
|
pipe->status.poped_size += gst_buffer_get_size(*buffer);
|
|
}
|
|
|
|
GST_TRACE("pipe:%p, type:%d, poped out buffer %p, status.cur_num:%d, status.cur_size:%d, ret:%d", pipe, pipe->type, *buffer, pipe->status.cur_num, pipe->status.cur_size, ret);
|
|
return ret;
|
|
}
|
|
|
|
/* public interfaces */
|
|
GstAdapterPipe *gst_amladapterpipe_new()
|
|
{
|
|
GstAdapterPipe *pipe;
|
|
pipe = calloc(1, sizeof(GstAdapterPipe));
|
|
memset(pipe, 0, sizeof(GstAdapterPipe));
|
|
gst_amladapterpipe_init(pipe, GST_AP_TS, FALSE, FALSE);
|
|
return pipe;
|
|
}
|
|
|
|
GstAdapterPipe *gst_amladapterpipe_new_full(GstAdapterPipeDataType type, gboolean is_secure, gboolean is_unlimit)
|
|
{
|
|
GstAdapterPipe *pipe;
|
|
pipe = calloc(1, sizeof(GstAdapterPipe));
|
|
g_return_val_if_fail(pipe, NULL);
|
|
memset(pipe, 0, sizeof(GstAdapterPipe));
|
|
gst_amladapterpipe_init(pipe, type, is_secure, is_unlimit);
|
|
return pipe;
|
|
}
|
|
|
|
void gst_amladapterpipe_free(GstAdapterPipe *pipe)
|
|
{
|
|
g_return_if_fail(pipe);
|
|
gst_amladapterpipe_reset(pipe);
|
|
gst_amladapterpipe_dispose(pipe);
|
|
free(pipe);
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_reset(GstAdapterPipe *pipe)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
|
|
GstFlowReturn ret;
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
ret = gst_amladapterpipe_clear_unlock(pipe);
|
|
pipe->eos = FALSE;
|
|
pipe->srcresult = GST_FLOW_OK;
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
|
|
g_mutex_clear(&pipe->tlock);
|
|
g_cond_clear(&pipe->cond);
|
|
|
|
return ret;
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_clear(GstAdapterPipe *pipe)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
|
|
GstFlowReturn ret;
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
ret = gst_amladapterpipe_clear_unlock(pipe);
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
|
|
return ret;
|
|
}
|
|
|
|
gboolean gst_amladapterpipe_get_status(GstAdapterPipe *pipe, GstAdapterPipeStatus *status)
|
|
{
|
|
g_return_val_if_fail(pipe, FALSE);
|
|
g_return_val_if_fail(status, FALSE);
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
memcpy(status, &pipe->status, sizeof(GstAdapterPipeStatus));
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_push(GstAdapterPipe *pipe, GstBuffer *buffer)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
g_return_val_if_fail(buffer, GST_FLOW_ERROR);
|
|
|
|
GstFlowReturn ret;
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
|
|
if (pipe->flushing)
|
|
goto flushing;
|
|
|
|
while (!pipe->unlimit && (pipe->status.cur_num + 1 > pipe->status.max_num || pipe->status.cur_size + gst_buffer_get_size(buffer) > pipe->status.max_size))
|
|
{
|
|
GST_TRACE("pipe:%p, type:%d, reached max, [status.cur_num:%d, status.max_num:%d], [status.cur_size:%d, status.max_size:%d], waitting sig",
|
|
pipe, pipe->type, pipe->status.cur_num, pipe->status.max_num, pipe->status.cur_size, pipe->status.max_size);
|
|
GST_ADAPTER_PIPE_WAIT(pipe);
|
|
GST_TRACE("pipe:%p, type:%d, waitted", pipe, pipe->type);
|
|
}
|
|
|
|
if (pipe->flushing)
|
|
goto flushing;
|
|
|
|
ret = gst_amladapterpipe_push_uncheck_unlock(pipe, buffer);
|
|
|
|
if (!pipe->unlimit && (pipe->status.cur_num >= pipe->status.needed_num && pipe->status.cur_size >= pipe->status.needed_size))
|
|
{
|
|
GST_TRACE("pipe:%p, type:%d, reachd needed, [status.cur_num:%d, status.needed_num:%d], [status.cur_size:%d, status.needed_size:%d], emit sig",
|
|
pipe, pipe->type, pipe->status.cur_num, pipe->status.needed_num, pipe->status.cur_size, pipe->status.needed_size);
|
|
GST_ADAPTER_PIPE_SIGNAL(pipe);
|
|
}
|
|
|
|
if (ret != GST_FLOW_OK)
|
|
{
|
|
GST_ERROR("pipe:%p, type:%d, push return err:%d", pipe, pipe->type, ret);
|
|
goto done;
|
|
}
|
|
|
|
GST_TRACE("pipe:%p, type:%d, pushed buf:%p(%d bytes), status.cur_num:%d, status.cur_size:%d",
|
|
pipe, pipe->type, buffer, buffer ? gst_buffer_get_size(buffer) : -1, pipe->status.cur_num, pipe->status.cur_size);
|
|
done:
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
return ret;
|
|
flushing:
|
|
GST_DEBUG("pipe:%p, type:%d, flushing, clear adapter", pipe, pipe->type);
|
|
gst_buffer_unref(buffer);
|
|
gst_amladapterpipe_clear_unlock(pipe);
|
|
ret = GST_FLOW_FLUSHING;
|
|
goto done;
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_pop(GstAdapterPipe *pipe, GstBuffer **buffer)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
g_return_val_if_fail(buffer, GST_FLOW_ERROR);
|
|
|
|
GstFlowReturn ret;
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
|
|
while (!pipe->unlimit && (pipe->status.cur_num < pipe->status.needed_num || pipe->status.cur_size < pipe->status.needed_size) && !pipe->eos)
|
|
{
|
|
gboolean waitted;
|
|
|
|
GST_TRACE("pipe:%p, type:%d, need more, [status.cur_num:%d, status.needed_num:%d], [status.cur_size:%d, status.needed_size:%d]",
|
|
pipe, pipe->type, pipe->status.cur_num, pipe->status.needed_num, pipe->status.cur_size, pipe->status.needed_size);
|
|
|
|
if (pipe->flushing)
|
|
goto flushing;
|
|
|
|
GST_ADAPTER_PIPE_WAITT_TIME(pipe, 20, waitted);
|
|
if (!waitted)
|
|
{
|
|
GST_TRACE("pipe:%p, type:%d, timeout. need continue", pipe, pipe->type);
|
|
continue;
|
|
}
|
|
|
|
GST_TRACE("pipe:%p, type:%d, waitted", pipe, pipe->type);
|
|
break;
|
|
}
|
|
|
|
ret = gst_amladapterpipe_pop_uncheck_unlock(pipe, buffer);
|
|
if (ret == GST_FLOW_AMLAP_EMPTY)
|
|
{
|
|
GST_TRACE("pipe:%p, type:%d, poped buf:%p, status.cur_num:%d, status.cur_size:%d, pipe empty, need retry",
|
|
pipe, pipe->type, *buffer, pipe->status.cur_num, pipe->status.cur_size);
|
|
goto done;
|
|
}
|
|
|
|
GST_TRACE("pipe:%p, type:%d, poped buf:%p(%d bytes), status.cur_num:%d, status.cur_size:%d",
|
|
pipe, pipe->type, *buffer, *buffer ? gst_buffer_get_size(*buffer) : -1, pipe->status.cur_num, pipe->status.cur_size);
|
|
|
|
done:
|
|
if (!pipe->unlimit && (pipe->status.cur_num <= pipe->status.low_num || pipe->status.cur_size <= pipe->status.low_size))
|
|
{
|
|
GST_TRACE("pipe:%p, type:%d, buffer low, [status.cur_num:%d, status.low_num:%d], [status.cur_size:%d, status.low_size:%d]",
|
|
pipe, pipe->type, pipe->status.cur_num, pipe->status.low_num, pipe->status.cur_size, pipe->status.low_size);
|
|
GST_ADAPTER_PIPE_SIGNAL(pipe);
|
|
}
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
return ret;
|
|
flushing:
|
|
GST_DEBUG("pipe:%p, type:%d, flushing, clear adapter", pipe, pipe->type);
|
|
gst_amladapterpipe_clear_unlock(pipe);
|
|
ret = GST_FLOW_FLUSHING;
|
|
goto done;
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_peek(GstAdapterPipe *pipe, GstBuffer **buffer)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
g_return_val_if_fail(buffer, GST_FLOW_ERROR);
|
|
|
|
GstFlowReturn ret;
|
|
|
|
ret = GST_FLOW_AMLAP_EMPTY;
|
|
*buffer = NULL;
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
|
|
if (pipe->secure)
|
|
{
|
|
if (gst_queue_array_get_length(pipe->s.secure_ap.sec_buf_q) <= pipe->s.secure_ap.prob_peek_idx)
|
|
{
|
|
GST_TRACE("pipe:%p, type:%d, peek err. q len < idx", pipe, pipe->type);
|
|
}
|
|
else
|
|
{
|
|
*buffer = (GstBuffer *)gst_queue_array_peek_nth(pipe->s.secure_ap.sec_buf_q, pipe->s.secure_ap.prob_peek_idx);
|
|
if (*buffer)
|
|
{
|
|
gst_buffer_ref(*buffer);
|
|
// pipe->s.secure_ap.prob_peek_idx++;
|
|
ret = GST_FLOW_OK;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
guint available = gst_adapter_available(pipe->s.clear_ap.adapter);
|
|
if (available < BUFFER_SIZE + pipe->s.clear_ap.prob_peek_offset)
|
|
{
|
|
GST_TRACE("pipe:%p, type:%d, peek err. q available:%d < BUFFER_SIZE", pipe, pipe->type, available);
|
|
}
|
|
else
|
|
{
|
|
GstMapInfo map;
|
|
memset(&map, 0, sizeof(map));
|
|
*buffer = gst_buffer_new_and_alloc(BUFFER_SIZE);
|
|
if (*buffer)
|
|
{
|
|
gst_buffer_map(*buffer, &map, GST_MAP_WRITE);
|
|
gst_adapter_copy(pipe->s.clear_ap.adapter, map.data, pipe->s.clear_ap.prob_peek_offset, BUFFER_SIZE);
|
|
gst_buffer_unmap(*buffer, &map);
|
|
pipe->s.clear_ap.prob_peek_offset += BUFFER_SIZE;
|
|
ret = GST_FLOW_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
GST_TRACE("pipe:%p, type:%d, peeked buf:%p(%d bytes), ret:%d", pipe, pipe->type, *buffer, *buffer ? gst_buffer_get_size(*buffer) : -1, ret);
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
return ret;
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_set_flushing(GstAdapterPipe *pipe, gboolean flushing)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
|
|
GstFlowReturn ret;
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
GST_TRACE("pipe:%p, type:%d, set flushing to %d", pipe, pipe->type, flushing);
|
|
pipe->flushing = flushing;
|
|
ret = gst_amladapterpipe_clear_unlock(pipe);
|
|
if (!pipe->unlimit)
|
|
GST_ADAPTER_PIPE_SIGNAL(pipe);
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
|
|
return ret;
|
|
}
|
|
|
|
GstFlowReturn gst_amladapterpipe_is_flushing(GstAdapterPipe *pipe, gboolean *flushing)
|
|
{
|
|
g_return_val_if_fail(pipe, GST_FLOW_ERROR);
|
|
g_return_val_if_fail(flushing, GST_FLOW_ERROR);
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
*flushing = pipe->flushing;
|
|
GST_TRACE("pipe:%p, type:%d, is flushing:%d", pipe, pipe->type, pipe->flushing);
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
|
|
return GST_FLOW_OK;
|
|
}
|
|
|
|
void gst_amladapterpipe_set_eos(GstAdapterPipe *pipe)
|
|
{
|
|
g_return_if_fail(pipe);
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
GST_TRACE("pipe:%p, type:%d, set eos", pipe, pipe->type);
|
|
pipe->eos = TRUE;
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
}
|
|
|
|
gboolean gst_amladapterpipe_is_eos(GstAdapterPipe *pipe)
|
|
{
|
|
g_return_val_if_fail(pipe, FALSE);
|
|
|
|
gboolean ret;
|
|
|
|
GST_ADAPTER_PIPE_MUTEX_LOCK(pipe);
|
|
ret = pipe->eos;
|
|
GST_DEBUG("pipe:%p, type:%d, is eos:%d", pipe, pipe->type, ret);
|
|
GST_ADAPTER_PIPE_MUTEX_UNLOCK(pipe);
|
|
|
|
return ret;
|
|
} |