| /* GStreamer |
| * Copyright (C) 2010 David Schleef <ds@schleef.org> |
| * |
| * 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. |
| */ |
| /** |
| * SECTION:element-gsty4mdec |
| * |
| * The gsty4mdec element decodes uncompressed video in YUV4MPEG format. |
| * |
| * <refsect2> |
| * <title>Example launch line</title> |
| * |[ |
| * gst-launch-1.0 -v filesrc location=file.y4m ! y4mdec ! xvimagesink |
| * ]| |
| * </refsect2> |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #include <gst/gst.h> |
| #include <gst/video/video.h> |
| #include "gsty4mdec.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #define MAX_SIZE 32768 |
| |
| GST_DEBUG_CATEGORY (y4mdec_debug); |
| #define GST_CAT_DEFAULT y4mdec_debug |
| |
| /* prototypes */ |
| |
| |
| static void gst_y4m_dec_set_property (GObject * object, |
| guint property_id, const GValue * value, GParamSpec * pspec); |
| static void gst_y4m_dec_get_property (GObject * object, |
| guint property_id, GValue * value, GParamSpec * pspec); |
| static void gst_y4m_dec_dispose (GObject * object); |
| static void gst_y4m_dec_finalize (GObject * object); |
| |
| static GstFlowReturn gst_y4m_dec_chain (GstPad * pad, GstObject * parent, |
| GstBuffer * buffer); |
| static gboolean gst_y4m_dec_sink_event (GstPad * pad, GstObject * parent, |
| GstEvent * event); |
| |
| static gboolean gst_y4m_dec_src_event (GstPad * pad, GstObject * parent, |
| GstEvent * event); |
| static gboolean gst_y4m_dec_src_query (GstPad * pad, GstObject * parent, |
| GstQuery * query); |
| |
| static GstStateChangeReturn |
| gst_y4m_dec_change_state (GstElement * element, GstStateChange transition); |
| |
| enum |
| { |
| PROP_0 |
| }; |
| |
| /* pad templates */ |
| |
| static GstStaticPadTemplate gst_y4m_dec_sink_template = |
| GST_STATIC_PAD_TEMPLATE ("sink", |
| GST_PAD_SINK, |
| GST_PAD_ALWAYS, |
| GST_STATIC_CAPS ("application/x-yuv4mpeg, y4mversion=2") |
| ); |
| |
| static GstStaticPadTemplate gst_y4m_dec_src_template = |
| GST_STATIC_PAD_TEMPLATE ("src", |
| GST_PAD_SRC, |
| GST_PAD_ALWAYS, |
| GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{I420,Y42B,Y444}")) |
| ); |
| |
| /* class initialization */ |
| #define gst_y4m_dec_parent_class parent_class |
| G_DEFINE_TYPE (GstY4mDec, gst_y4m_dec, GST_TYPE_ELEMENT); |
| |
| static void |
| gst_y4m_dec_class_init (GstY4mDecClass * klass) |
| { |
| GObjectClass *gobject_class = G_OBJECT_CLASS (klass); |
| GstElementClass *element_class = GST_ELEMENT_CLASS (klass); |
| |
| gobject_class->set_property = gst_y4m_dec_set_property; |
| gobject_class->get_property = gst_y4m_dec_get_property; |
| gobject_class->dispose = gst_y4m_dec_dispose; |
| gobject_class->finalize = gst_y4m_dec_finalize; |
| |
| element_class->change_state = GST_DEBUG_FUNCPTR (gst_y4m_dec_change_state); |
| |
| gst_element_class_add_static_pad_template (element_class, |
| &gst_y4m_dec_src_template); |
| gst_element_class_add_static_pad_template (element_class, |
| &gst_y4m_dec_sink_template); |
| |
| gst_element_class_set_static_metadata (element_class, |
| "YUV4MPEG demuxer/decoder", "Codec/Demuxer", |
| "Demuxes/decodes YUV4MPEG streams", "David Schleef <ds@schleef.org>"); |
| } |
| |
| static void |
| gst_y4m_dec_init (GstY4mDec * y4mdec) |
| { |
| y4mdec->adapter = gst_adapter_new (); |
| |
| y4mdec->sinkpad = |
| gst_pad_new_from_static_template (&gst_y4m_dec_sink_template, "sink"); |
| gst_pad_set_event_function (y4mdec->sinkpad, |
| GST_DEBUG_FUNCPTR (gst_y4m_dec_sink_event)); |
| gst_pad_set_chain_function (y4mdec->sinkpad, |
| GST_DEBUG_FUNCPTR (gst_y4m_dec_chain)); |
| gst_element_add_pad (GST_ELEMENT (y4mdec), y4mdec->sinkpad); |
| |
| y4mdec->srcpad = gst_pad_new_from_static_template (&gst_y4m_dec_src_template, |
| "src"); |
| gst_pad_set_event_function (y4mdec->srcpad, |
| GST_DEBUG_FUNCPTR (gst_y4m_dec_src_event)); |
| gst_pad_set_query_function (y4mdec->srcpad, |
| GST_DEBUG_FUNCPTR (gst_y4m_dec_src_query)); |
| gst_pad_use_fixed_caps (y4mdec->srcpad); |
| gst_element_add_pad (GST_ELEMENT (y4mdec), y4mdec->srcpad); |
| |
| } |
| |
| void |
| gst_y4m_dec_set_property (GObject * object, guint property_id, |
| const GValue * value, GParamSpec * pspec) |
| { |
| g_return_if_fail (GST_IS_Y4M_DEC (object)); |
| |
| switch (property_id) { |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); |
| break; |
| } |
| } |
| |
| void |
| gst_y4m_dec_get_property (GObject * object, guint property_id, |
| GValue * value, GParamSpec * pspec) |
| { |
| g_return_if_fail (GST_IS_Y4M_DEC (object)); |
| |
| switch (property_id) { |
| default: |
| G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); |
| break; |
| } |
| } |
| |
| 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); |
| } |
| |
| void |
| gst_y4m_dec_finalize (GObject * object) |
| { |
| g_return_if_fail (GST_IS_Y4M_DEC (object)); |
| |
| /* clean up object here */ |
| |
| G_OBJECT_CLASS (parent_class)->finalize (object); |
| } |
| |
| 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 GstClockTime |
| gst_y4m_dec_frames_to_timestamp (GstY4mDec * y4mdec, gint64 frame_index) |
| { |
| if (frame_index == -1) |
| return -1; |
| |
| return gst_util_uint64_scale (frame_index, GST_SECOND * y4mdec->info.fps_d, |
| y4mdec->info.fps_n); |
| } |
| |
| static gint64 |
| gst_y4m_dec_timestamp_to_frames (GstY4mDec * y4mdec, GstClockTime timestamp) |
| { |
| if (timestamp == -1) |
| return -1; |
| |
| return gst_util_uint64_scale (timestamp, y4mdec->info.fps_n, |
| GST_SECOND * y4mdec->info.fps_d); |
| } |
| |
| static gint64 |
| gst_y4m_dec_bytes_to_frames (GstY4mDec * y4mdec, gint64 bytes) |
| { |
| if (bytes == -1) |
| return -1; |
| |
| if (bytes < y4mdec->header_size) |
| return 0; |
| return (bytes - y4mdec->header_size) / (y4mdec->info.size + 6); |
| } |
| |
| static guint64 |
| gst_y4m_dec_frames_to_bytes (GstY4mDec * y4mdec, gint64 frame_index) |
| { |
| if (frame_index == -1) |
| return -1; |
| |
| return y4mdec->header_size + (y4mdec->info.size + 6) * frame_index; |
| } |
| |
| static GstClockTime |
| gst_y4m_dec_bytes_to_timestamp (GstY4mDec * y4mdec, gint64 bytes) |
| { |
| if (bytes == -1) |
| return -1; |
| |
| return gst_y4m_dec_frames_to_timestamp (y4mdec, |
| gst_y4m_dec_bytes_to_frames (y4mdec, bytes)); |
| } |
| |
| |
| static gboolean |
| gst_y4m_dec_parse_header (GstY4mDec * y4mdec, char *header) |
| { |
| char *end; |
| int iformat = 420; |
| int interlaced_char = 0; |
| gint fps_n = 0, fps_d = 0; |
| gint par_n = 0, par_d = 0; |
| gint width = 0, height = 0; |
| GstVideoFormat format; |
| |
| if (memcmp (header, "YUV4MPEG2 ", 10) != 0) { |
| return FALSE; |
| } |
| |
| header += 10; |
| while (*header) { |
| GST_DEBUG_OBJECT (y4mdec, "parsing at '%s'", header); |
| switch (*header) { |
| case ' ': |
| header++; |
| break; |
| case 'C': |
| header++; |
| iformat = strtoul (header, &end, 10); |
| if (end == header) |
| goto error; |
| header = end; |
| break; |
| case 'W': |
| header++; |
| width = strtoul (header, &end, 10); |
| if (end == header) |
| goto error; |
| header = end; |
| break; |
| case 'H': |
| header++; |
| height = strtoul (header, &end, 10); |
| if (end == header) |
| goto error; |
| header = end; |
| break; |
| case 'I': |
| header++; |
| if (header[0] == 0) { |
| GST_WARNING_OBJECT (y4mdec, "Expecting interlaced flag"); |
| return FALSE; |
| } |
| interlaced_char = header[0]; |
| header++; |
| break; |
| case 'F': |
| header++; |
| fps_n = strtoul (header, &end, 10); |
| if (end == header) |
| goto error; |
| header = end; |
| if (header[0] != ':') { |
| GST_WARNING_OBJECT (y4mdec, "Expecting :"); |
| return FALSE; |
| } |
| header++; |
| fps_d = strtoul (header, &end, 10); |
| if (end == header) |
| goto error; |
| header = end; |
| break; |
| case 'A': |
| header++; |
| par_n = strtoul (header, &end, 10); |
| if (end == header) |
| goto error; |
| header = end; |
| if (header[0] != ':') { |
| GST_WARNING_OBJECT (y4mdec, "Expecting :"); |
| return FALSE; |
| } |
| header++; |
| par_d = strtoul (header, &end, 10); |
| if (end == header) |
| goto error; |
| header = end; |
| break; |
| default: |
| GST_WARNING_OBJECT (y4mdec, "Unknown y4m header field '%c', ignoring", |
| *header); |
| while (*header && *header != ' ') |
| header++; |
| break; |
| } |
| } |
| |
| switch (iformat) { |
| case 420: |
| format = GST_VIDEO_FORMAT_I420; |
| break; |
| case 422: |
| format = GST_VIDEO_FORMAT_Y42B; |
| break; |
| case 444: |
| format = GST_VIDEO_FORMAT_Y444; |
| break; |
| default: |
| GST_WARNING_OBJECT (y4mdec, "unknown y4m format %d", iformat); |
| return FALSE; |
| } |
| |
| if (width <= 0 || width > MAX_SIZE || height <= 0 || height > MAX_SIZE) { |
| GST_WARNING_OBJECT (y4mdec, "Dimensions %dx%d out of range", width, height); |
| return FALSE; |
| } |
| |
| gst_video_info_init (&y4mdec->info); |
| gst_video_info_set_format (&y4mdec->out_info, format, width, height); |
| y4mdec->info = y4mdec->out_info; |
| |
| switch (y4mdec->info.finfo->format) { |
| case GST_VIDEO_FORMAT_I420: |
| y4mdec->info.offset[0] = 0; |
| y4mdec->info.stride[0] = width; |
| y4mdec->info.offset[1] = y4mdec->info.stride[0] * height; |
| y4mdec->info.stride[1] = GST_ROUND_UP_2 (width) / 2; |
| y4mdec->info.offset[2] = |
| y4mdec->info.offset[1] + |
| y4mdec->info.stride[1] * (GST_ROUND_UP_2 (height) / 2); |
| y4mdec->info.stride[2] = GST_ROUND_UP_2 (width) / 2; |
| y4mdec->info.size = |
| y4mdec->info.offset[2] + |
| y4mdec->info.stride[2] * (GST_ROUND_UP_2 (height) / 2); |
| break; |
| case GST_VIDEO_FORMAT_Y42B: |
| y4mdec->info.offset[0] = 0; |
| y4mdec->info.stride[0] = width; |
| y4mdec->info.offset[1] = y4mdec->info.stride[0] * height; |
| y4mdec->info.stride[1] = GST_ROUND_UP_2 (width) / 2; |
| y4mdec->info.offset[2] = |
| y4mdec->info.offset[1] + y4mdec->info.stride[1] * height; |
| y4mdec->info.stride[2] = GST_ROUND_UP_2 (width) / 2; |
| y4mdec->info.size = |
| y4mdec->info.offset[2] + y4mdec->info.stride[2] * height; |
| break; |
| case GST_VIDEO_FORMAT_Y444: |
| y4mdec->info.offset[0] = 0; |
| y4mdec->info.stride[0] = width; |
| y4mdec->info.offset[1] = y4mdec->info.stride[0] * height; |
| y4mdec->info.stride[1] = width; |
| y4mdec->info.offset[2] = |
| y4mdec->info.offset[1] + y4mdec->info.stride[1] * height; |
| y4mdec->info.stride[2] = width; |
| y4mdec->info.size = |
| y4mdec->info.offset[2] + y4mdec->info.stride[2] * height; |
| break; |
| default: |
| g_assert_not_reached (); |
| break; |
| } |
| |
| switch (interlaced_char) { |
| case 0: |
| case '?': |
| case 'p': |
| y4mdec->info.interlace_mode = GST_VIDEO_INTERLACE_MODE_PROGRESSIVE; |
| break; |
| case 't': |
| case 'b': |
| y4mdec->info.interlace_mode = GST_VIDEO_INTERLACE_MODE_INTERLEAVED; |
| break; |
| default: |
| GST_WARNING_OBJECT (y4mdec, "Unknown interlaced char '%c'", |
| interlaced_char); |
| return FALSE; |
| break; |
| } |
| |
| if (fps_n == 0) |
| fps_n = 1; |
| if (fps_d == 0) |
| fps_d = 1; |
| if (par_n == 0) |
| par_n = 1; |
| if (par_d == 0) |
| par_d = 1; |
| |
| y4mdec->info.fps_n = fps_n; |
| y4mdec->info.fps_d = fps_d; |
| y4mdec->info.par_n = par_n; |
| y4mdec->info.par_d = par_d; |
| |
| return TRUE; |
| error: |
| GST_WARNING_OBJECT (y4mdec, "Expecting number y4m header at '%s'", header); |
| return FALSE; |
| } |
| |
| 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; |
| } |
| |
| 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: |
| default: |
| res = gst_pad_event_default (pad, parent, event); |
| break; |
| } |
| |
| 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; |
| } |
| |
| static gboolean |
| gst_y4m_dec_src_query (GstPad * pad, GstObject * parent, GstQuery * query) |
| { |
| GstY4mDec *y4mdec = GST_Y4M_DEC (parent); |
| gboolean res = FALSE; |
| |
| switch (GST_QUERY_TYPE (query)) { |
| case GST_QUERY_DURATION: |
| { |
| GstFormat format; |
| GstQuery *peer_query; |
| |
| 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_query = gst_query_new_duration (GST_FORMAT_BYTES); |
| |
| res = gst_pad_peer_query (y4mdec->sinkpad, 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); |
| break; |
| } |
| default: |
| res = gst_pad_query_default (pad, parent, query); |
| break; |
| } |
| |
| return res; |
| } |
| |
| |
| static gboolean |
| plugin_init (GstPlugin * plugin) |
| { |
| |
| gst_element_register (plugin, "y4mdec", GST_RANK_SECONDARY, |
| gst_y4m_dec_get_type ()); |
| |
| GST_DEBUG_CATEGORY_INIT (y4mdec_debug, "y4mdec", 0, "y4mdec element"); |
| |
| return TRUE; |
| } |
| |
| |
| GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, |
| GST_VERSION_MINOR, |
| y4mdec, |
| "Demuxes/decodes YUV4MPEG streams", |
| plugin_init, VERSION, "LGPL", PACKAGE_NAME, GST_PACKAGE_ORIGIN) |