static gboolean
gst_y4m_dec_sink_event (GstPad * pad, GstEvent * event)
{
gboolean res;
GstY4mDec *y4mdec;
y4mdec = GST_Y4M_DEC (gst_pad_get_parent (pad));
GST_DEBUG_OBJECT (y4mdec, "event");
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_FLUSH_START:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
case GST_EVENT_FLUSH_STOP:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
case GST_EVENT_NEWSEGMENT:
{
gboolean update;
gdouble rate;
gdouble applied_rate;
GstFormat format;
gint64 start;
gint64 stop;
gint64 position;
gst_event_parse_new_segment_full (event, &update, &rate,
&applied_rate, &format, &start, &stop, &position);
GST_DEBUG ("new_segment: update: %d rate: %g applied_rate: %g "
"format: %d start: %" G_GUINT64_FORMAT " stop: %" G_GUINT64_FORMAT
" position %" G_GUINT64_FORMAT,
update, rate, applied_rate, format, start, stop, position);
if (format == GST_FORMAT_BYTES) {
y4mdec->segment_start = start;
y4mdec->segment_stop = stop;
y4mdec->segment_position = position;
y4mdec->have_new_segment = TRUE;
}
res = TRUE;
/* not sure why it's not forwarded, but let's unref it so it
doesn't leak, remove the unref if it gets forwarded again */
gst_event_unref (event);
//res = gst_pad_push_event (y4mdec->srcpad, event);
}
break;
case GST_EVENT_EOS:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
default:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
}
gst_object_unref (y4mdec);
return res;
}
static gboolean
gst_y4m_dec_src_query (GstPad * pad, GstQuery * query)
{
GstY4mDec *y4mdec = GST_Y4M_DEC (gst_pad_get_parent (pad));
gboolean res = FALSE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:
{
GstFormat format;
GstPad *peer;
GST_DEBUG ("duration query");
gst_query_parse_duration (query, &format, NULL);
if (format != GST_FORMAT_TIME) {
res = FALSE;
GST_DEBUG_OBJECT (y4mdec, "not handling duration query in format %d",
format);
break;
}
peer = gst_pad_get_peer (y4mdec->sinkpad);
if (peer) {
GstQuery *peer_query = gst_query_new_duration (GST_FORMAT_BYTES);
res = gst_pad_query (peer, peer_query);
if (res) {
gint64 duration;
int n_frames;
gst_query_parse_duration (peer_query, &format, &duration);
n_frames = gst_y4m_dec_bytes_to_frames (y4mdec, duration);
GST_DEBUG ("duration in frames %d", n_frames);
duration = gst_y4m_dec_frames_to_timestamp (y4mdec, n_frames);
GST_DEBUG ("duration in time %" GST_TIME_FORMAT,
GST_TIME_ARGS (duration));
gst_query_set_duration (query, GST_FORMAT_TIME, duration);
res = TRUE;
}
gst_query_unref (peer_query);
gst_object_unref (peer);
}
break;
}
default:
res = gst_pad_query_default (pad, query);
break;
}
gst_object_unref (y4mdec);
return res;
}
static gboolean
gst_y4m_dec_src_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
gboolean res;
GstY4mDec *y4mdec;
y4mdec = GST_Y4M_DEC (parent);
GST_DEBUG_OBJECT (y4mdec, "event");
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEEK:
{
gdouble rate;
GstFormat format;
GstSeekFlags flags;
GstSeekType start_type, stop_type;
gint64 start, stop;
gint64 framenum;
guint64 byte;
gst_event_parse_seek (event, &rate, &format, &flags, &start_type,
&start, &stop_type, &stop);
if (format != GST_FORMAT_TIME) {
res = FALSE;
break;
}
framenum = gst_y4m_dec_timestamp_to_frames (y4mdec, start);
GST_DEBUG ("seeking to frame %" G_GINT64_FORMAT, framenum);
if (framenum == -1) {
res = FALSE;
break;
}
byte = gst_y4m_dec_frames_to_bytes (y4mdec, framenum);
GST_DEBUG ("offset %" G_GUINT64_FORMAT, (guint64) byte);
if (byte == -1) {
res = FALSE;
break;
}
gst_event_unref (event);
event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags,
start_type, byte, stop_type, -1);
res = gst_pad_push_event (y4mdec->sinkpad, event);
}
break;
default:
res = gst_pad_event_default (pad, parent, event);
break;
}
return res;
}
void
gst_y4m_dec_dispose (GObject * object)
{
GstY4mDec *y4mdec;
g_return_if_fail (GST_IS_Y4M_DEC (object));
y4mdec = GST_Y4M_DEC (object);
/* clean up as possible. may be called multiple times */
if (y4mdec->adapter) {
g_object_unref (y4mdec->adapter);
y4mdec->adapter = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static gboolean
gst_y4m_dec_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
gboolean res;
GstY4mDec *y4mdec;
y4mdec = GST_Y4M_DEC (parent);
GST_DEBUG_OBJECT (y4mdec, "event");
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_FLUSH_START:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
case GST_EVENT_FLUSH_STOP:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
case GST_EVENT_SEGMENT:
{
GstSegment seg;
gst_event_copy_segment (event, &seg);
GST_DEBUG ("segment: %" GST_SEGMENT_FORMAT, &seg);
if (seg.format == GST_FORMAT_BYTES) {
y4mdec->segment = seg;
y4mdec->have_new_segment = TRUE;
}
res = TRUE;
/* not sure why it's not forwarded, but let's unref it so it
doesn't leak, remove the unref if it gets forwarded again */
gst_event_unref (event);
//res = gst_pad_push_event (y4mdec->srcpad, event);
}
break;
case GST_EVENT_EOS:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
default:
res = gst_pad_push_event (y4mdec->srcpad, event);
break;
}
return res;
}
static GstStateChangeReturn
gst_y4m_dec_change_state (GstElement * element, GstStateChange transition)
{
GstY4mDec *y4mdec;
GstStateChangeReturn ret;
g_return_val_if_fail (GST_IS_Y4M_DEC (element), GST_STATE_CHANGE_FAILURE);
y4mdec = GST_Y4M_DEC (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
if (y4mdec->pool) {
gst_buffer_pool_set_active (y4mdec->pool, FALSE);
gst_object_unref (y4mdec->pool);
}
y4mdec->pool = NULL;
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
default:
break;
}
return ret;
}
static GstFlowReturn
gst_y4m_dec_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstY4mDec *y4mdec;
int n_avail;
GstFlowReturn flow_ret = GST_FLOW_OK;
#define MAX_HEADER_LENGTH 80
char header[MAX_HEADER_LENGTH];
int i;
int len;
y4mdec = GST_Y4M_DEC (parent);
GST_DEBUG_OBJECT (y4mdec, "chain");
if (GST_BUFFER_IS_DISCONT (buffer)) {
GST_DEBUG ("got discont");
gst_adapter_clear (y4mdec->adapter);
}
gst_adapter_push (y4mdec->adapter, buffer);
n_avail = gst_adapter_available (y4mdec->adapter);
if (!y4mdec->have_header) {
gboolean ret;
GstCaps *caps;
if (n_avail < MAX_HEADER_LENGTH)
return GST_FLOW_OK;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
ret = gst_y4m_dec_parse_header (y4mdec, header);
if (!ret) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG header"), (NULL));
return GST_FLOW_ERROR;
}
y4mdec->header_size = strlen (header) + 1;
gst_adapter_flush (y4mdec->adapter, y4mdec->header_size);
caps = gst_video_info_to_caps (&y4mdec->info);
ret = gst_pad_set_caps (y4mdec->srcpad, caps);
gst_caps_unref (caps);
if (!ret) {
GST_DEBUG_OBJECT (y4mdec, "Couldn't set caps on src pad");
return GST_FLOW_ERROR;
}
y4mdec->have_header = TRUE;
}
if (y4mdec->have_new_segment) {
GstEvent *event;
GstClockTime start = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.start);
GstClockTime stop = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.stop);
GstClockTime time = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.time);
GstSegment seg;
gst_segment_init (&seg, GST_FORMAT_TIME);
seg.start = start;
seg.stop = stop;
seg.time = time;
event = gst_event_new_segment (&seg);
gst_pad_push_event (y4mdec->srcpad, event);
//gst_event_unref (event);
y4mdec->have_new_segment = FALSE;
y4mdec->frame_index = gst_y4m_dec_bytes_to_frames (y4mdec,
y4mdec->segment.time);
GST_DEBUG ("new frame_index %d", y4mdec->frame_index);
}
while (1) {
n_avail = gst_adapter_available (y4mdec->adapter);
if (n_avail < MAX_HEADER_LENGTH)
break;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
if (memcmp (header, "FRAME", 5) != 0) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG frame"), (NULL));
flow_ret = GST_FLOW_ERROR;
break;
}
len = strlen (header);
if (n_avail < y4mdec->info.size + len + 1) {
/* not enough data */
GST_DEBUG ("not enough data for frame %d < %" G_GSIZE_FORMAT,
n_avail, y4mdec->info.size + len + 1);
break;
}
gst_adapter_flush (y4mdec->adapter, len + 1);
buffer = gst_adapter_take_buffer (y4mdec->adapter, y4mdec->info.size);
GST_BUFFER_TIMESTAMP (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index);
GST_BUFFER_DURATION (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index + 1) -
GST_BUFFER_TIMESTAMP (buffer);
y4mdec->frame_index++;
flow_ret = gst_pad_push (y4mdec->srcpad, buffer);
if (flow_ret != GST_FLOW_OK)
break;
}
GST_DEBUG ("returning %d", flow_ret);
return flow_ret;
}
static GstFlowReturn
gst_y4m_dec_chain (GstPad * pad, GstBuffer * buffer)
{
GstY4mDec *y4mdec;
int n_avail;
GstFlowReturn flow_ret = GST_FLOW_OK;
#define MAX_HEADER_LENGTH 80
char header[MAX_HEADER_LENGTH];
int i;
int len;
y4mdec = GST_Y4M_DEC (gst_pad_get_parent (pad));
GST_DEBUG_OBJECT (y4mdec, "chain");
if (GST_BUFFER_IS_DISCONT (buffer)) {
GST_DEBUG ("got discont");
gst_adapter_clear (y4mdec->adapter);
}
gst_adapter_push (y4mdec->adapter, buffer);
n_avail = gst_adapter_available (y4mdec->adapter);
if (!y4mdec->have_header) {
gboolean ret;
GstCaps *caps;
if (n_avail < MAX_HEADER_LENGTH)
return GST_FLOW_OK;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
ret = gst_y4m_dec_parse_header (y4mdec, header);
if (!ret) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG header"), (NULL));
return GST_FLOW_ERROR;
}
y4mdec->header_size = strlen (header) + 1;
gst_adapter_flush (y4mdec->adapter, y4mdec->header_size);
caps = gst_video_format_new_caps_interlaced (y4mdec->format,
y4mdec->width, y4mdec->height,
y4mdec->fps_n, y4mdec->fps_d,
y4mdec->par_n, y4mdec->par_d, y4mdec->interlaced);
ret = gst_pad_set_caps (y4mdec->srcpad, caps);
gst_caps_unref (caps);
if (!ret) {
GST_DEBUG_OBJECT (y4mdec, "Couldn't set caps on src pad");
return GST_FLOW_ERROR;
}
y4mdec->have_header = TRUE;
}
if (y4mdec->have_new_segment) {
GstEvent *event;
GstClockTime start = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment_start);
GstClockTime stop = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment_stop);
GstClockTime position = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment_position);
event = gst_event_new_new_segment (FALSE, 1.0,
GST_FORMAT_TIME, start, stop, position);
gst_pad_push_event (y4mdec->srcpad, event);
//gst_event_unref (event);
y4mdec->have_new_segment = FALSE;
y4mdec->frame_index = gst_y4m_dec_bytes_to_frames (y4mdec,
y4mdec->segment_position);
GST_DEBUG ("new frame_index %d", y4mdec->frame_index);
}
while (1) {
n_avail = gst_adapter_available (y4mdec->adapter);
if (n_avail < MAX_HEADER_LENGTH)
break;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
if (memcmp (header, "FRAME", 5) != 0) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG frame"), (NULL));
flow_ret = GST_FLOW_ERROR;
break;
}
len = strlen (header);
if (n_avail < y4mdec->frame_size + len + 1) {
/* not enough data */
GST_DEBUG ("not enough data for frame %d < %d",
n_avail, y4mdec->frame_size + len + 1);
break;
}
gst_adapter_flush (y4mdec->adapter, len + 1);
buffer = gst_adapter_take_buffer (y4mdec->adapter, y4mdec->frame_size);
GST_BUFFER_CAPS (buffer) = gst_caps_ref (GST_PAD_CAPS (y4mdec->srcpad));
GST_BUFFER_TIMESTAMP (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index);
GST_BUFFER_DURATION (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index + 1) -
GST_BUFFER_TIMESTAMP (buffer);
if (y4mdec->interlaced && y4mdec->tff) {
GST_BUFFER_FLAG_SET (buffer, GST_VIDEO_BUFFER_TFF);
}
y4mdec->frame_index++;
flow_ret = gst_pad_push (y4mdec->srcpad, buffer);
if (flow_ret != GST_FLOW_OK)
break;
}
gst_object_unref (y4mdec);
GST_DEBUG ("returning %d", flow_ret);
return flow_ret;
}
static GstFlowReturn
gst_y4m_dec_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
{
GstY4mDec *y4mdec;
int n_avail;
GstFlowReturn flow_ret = GST_FLOW_OK;
#define MAX_HEADER_LENGTH 80
char header[MAX_HEADER_LENGTH];
int i;
int len;
y4mdec = GST_Y4M_DEC (parent);
GST_DEBUG_OBJECT (y4mdec, "chain");
if (GST_BUFFER_IS_DISCONT (buffer)) {
GST_DEBUG ("got discont");
gst_adapter_clear (y4mdec->adapter);
}
gst_adapter_push (y4mdec->adapter, buffer);
n_avail = gst_adapter_available (y4mdec->adapter);
if (!y4mdec->have_header) {
gboolean ret;
GstCaps *caps;
GstQuery *query;
if (n_avail < MAX_HEADER_LENGTH)
return GST_FLOW_OK;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
ret = gst_y4m_dec_parse_header (y4mdec, header);
if (!ret) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG header"), (NULL));
return GST_FLOW_ERROR;
}
y4mdec->header_size = strlen (header) + 1;
gst_adapter_flush (y4mdec->adapter, y4mdec->header_size);
caps = gst_video_info_to_caps (&y4mdec->info);
ret = gst_pad_set_caps (y4mdec->srcpad, caps);
query = gst_query_new_allocation (caps, FALSE);
y4mdec->video_meta = FALSE;
if (y4mdec->pool) {
gst_buffer_pool_set_active (y4mdec->pool, FALSE);
gst_object_unref (y4mdec->pool);
}
y4mdec->pool = NULL;
if (gst_pad_peer_query (y4mdec->srcpad, query)) {
y4mdec->video_meta =
gst_query_find_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
/* We only need a pool if we need to do stride conversion for downstream */
if (!y4mdec->video_meta && memcmp (&y4mdec->info, &y4mdec->out_info,
sizeof (y4mdec->info)) != 0) {
GstBufferPool *pool = NULL;
GstAllocator *allocator = NULL;
GstAllocationParams params;
GstStructure *config;
guint size, min, max;
if (gst_query_get_n_allocation_params (query) > 0) {
gst_query_parse_nth_allocation_param (query, 0, &allocator, ¶ms);
} else {
allocator = NULL;
gst_allocation_params_init (¶ms);
}
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min,
&max);
size = MAX (size, y4mdec->out_info.size);
} else {
pool = NULL;
size = y4mdec->out_info.size;
min = max = 0;
}
if (pool == NULL) {
pool = gst_video_buffer_pool_new ();
}
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_buffer_pool_config_set_allocator (config, allocator, ¶ms);
gst_buffer_pool_set_config (pool, config);
if (allocator)
gst_object_unref (allocator);
y4mdec->pool = pool;
}
} else if (memcmp (&y4mdec->info, &y4mdec->out_info,
sizeof (y4mdec->info)) != 0) {
GstBufferPool *pool;
GstStructure *config;
/* No pool, create our own if we need to do stride conversion */
pool = gst_video_buffer_pool_new ();
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, y4mdec->out_info.size, 0,
0);
gst_buffer_pool_set_config (pool, config);
y4mdec->pool = pool;
}
if (y4mdec->pool) {
gst_buffer_pool_set_active (y4mdec->pool, TRUE);
}
gst_query_unref (query);
gst_caps_unref (caps);
if (!ret) {
GST_DEBUG_OBJECT (y4mdec, "Couldn't set caps on src pad");
return GST_FLOW_ERROR;
}
y4mdec->have_header = TRUE;
}
if (y4mdec->have_new_segment) {
GstEvent *event;
GstClockTime start = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.start);
GstClockTime stop = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.stop);
GstClockTime time = gst_y4m_dec_bytes_to_timestamp (y4mdec,
y4mdec->segment.time);
GstSegment seg;
gst_segment_init (&seg, GST_FORMAT_TIME);
seg.start = start;
seg.stop = stop;
seg.time = time;
event = gst_event_new_segment (&seg);
gst_pad_push_event (y4mdec->srcpad, event);
//gst_event_unref (event);
y4mdec->have_new_segment = FALSE;
y4mdec->frame_index = gst_y4m_dec_bytes_to_frames (y4mdec,
y4mdec->segment.time);
GST_DEBUG ("new frame_index %d", y4mdec->frame_index);
}
while (1) {
n_avail = gst_adapter_available (y4mdec->adapter);
if (n_avail < MAX_HEADER_LENGTH)
break;
gst_adapter_copy (y4mdec->adapter, (guint8 *) header, 0, MAX_HEADER_LENGTH);
header[MAX_HEADER_LENGTH - 1] = 0;
for (i = 0; i < MAX_HEADER_LENGTH; i++) {
if (header[i] == 0x0a)
header[i] = 0;
}
if (memcmp (header, "FRAME", 5) != 0) {
GST_ELEMENT_ERROR (y4mdec, STREAM, DECODE,
("Failed to parse YUV4MPEG frame"), (NULL));
flow_ret = GST_FLOW_ERROR;
break;
}
len = strlen (header);
if (n_avail < y4mdec->info.size + len + 1) {
/* not enough data */
GST_DEBUG ("not enough data for frame %d < %" G_GSIZE_FORMAT,
n_avail, y4mdec->info.size + len + 1);
break;
}
gst_adapter_flush (y4mdec->adapter, len + 1);
buffer = gst_adapter_take_buffer (y4mdec->adapter, y4mdec->info.size);
GST_BUFFER_TIMESTAMP (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index);
GST_BUFFER_DURATION (buffer) =
gst_y4m_dec_frames_to_timestamp (y4mdec, y4mdec->frame_index + 1) -
GST_BUFFER_TIMESTAMP (buffer);
y4mdec->frame_index++;
if (y4mdec->video_meta) {
gst_buffer_add_video_meta_full (buffer, 0, y4mdec->info.finfo->format,
y4mdec->info.width, y4mdec->info.height, y4mdec->info.finfo->n_planes,
y4mdec->info.offset, y4mdec->info.stride);
} else if (memcmp (&y4mdec->info, &y4mdec->out_info,
sizeof (y4mdec->info)) != 0) {
GstBuffer *outbuf;
GstVideoFrame iframe, oframe;
gint i, j;
gint w, h, istride, ostride;
guint8 *src, *dest;
/* Allocate a new buffer and do stride conversion */
g_assert (y4mdec->pool != NULL);
flow_ret = gst_buffer_pool_acquire_buffer (y4mdec->pool, &outbuf, NULL);
if (flow_ret != GST_FLOW_OK) {
gst_buffer_unref (buffer);
break;
}
gst_video_frame_map (&iframe, &y4mdec->info, buffer, GST_MAP_READ);
gst_video_frame_map (&oframe, &y4mdec->out_info, outbuf, GST_MAP_WRITE);
for (i = 0; i < 3; i++) {
w = GST_VIDEO_FRAME_COMP_WIDTH (&iframe, i);
h = GST_VIDEO_FRAME_COMP_HEIGHT (&iframe, i);
istride = GST_VIDEO_FRAME_COMP_STRIDE (&iframe, i);
ostride = GST_VIDEO_FRAME_COMP_STRIDE (&oframe, i);
src = GST_VIDEO_FRAME_COMP_DATA (&iframe, i);
dest = GST_VIDEO_FRAME_COMP_DATA (&oframe, i);
for (j = 0; j < h; j++) {
memcpy (dest, src, w);
dest += ostride;
src += istride;
}
}
gst_video_frame_unmap (&iframe);
gst_video_frame_unmap (&oframe);
gst_buffer_copy_into (outbuf, buffer, GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
gst_buffer_unref (buffer);
buffer = outbuf;
}
flow_ret = gst_pad_push (y4mdec->srcpad, buffer);
if (flow_ret != GST_FLOW_OK)
break;
}
GST_DEBUG ("returning %d", flow_ret);
return flow_ret;
}