static GstStateChangeReturn
gst_gdk_pixbuf_dec_change_state (GstElement * element,
GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstGdkPixbufDec *dec = GST_GDK_PIXBUF_DEC (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
/* default to single image mode, setcaps function might not be called */
dec->in_fps_n = 0;
dec->in_fps_d = 1;
gst_video_info_init (&dec->info);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
dec->in_fps_n = 0;
dec->in_fps_d = 0;
if (dec->pool) {
gst_buffer_pool_set_active (dec->pool, FALSE);
gst_object_replace ((GstObject **) & dec->pool, NULL);
}
break;
default:
break;
}
return ret;
}
static GstCaps *
gst_video_parse_get_caps (GstRawParse * rp)
{
GstVideoParse *vp = GST_VIDEO_PARSE (rp);
GstVideoInfo info;
GstCaps *caps;
gint fps_n, fps_d;
gst_raw_parse_get_fps (rp, &fps_n, &fps_d);
gst_video_info_init (&info);
gst_video_info_set_format (&info, vp->format, vp->width, vp->height);
info.fps_n = fps_n;
info.fps_d = fps_d;
info.par_n = vp->par_n;
info.par_d = vp->par_d;
info.interlace_mode = vp->interlaced ?
GST_VIDEO_INTERLACE_MODE_INTERLEAVED :
GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
caps = gst_video_info_to_caps (&info);
return caps;
}
static GstStateChangeReturn
gst_dvbsub_overlay_change_state (GstElement * element,
GstStateChange transition)
{
GstDVBSubOverlay *render = GST_DVBSUB_OVERLAY (element);
GstStateChangeReturn ret;
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
break;
case GST_STATE_CHANGE_NULL_TO_READY:
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
gst_dvbsub_overlay_flush_subtitles (render);
gst_segment_init (&render->video_segment, GST_FORMAT_TIME);
gst_segment_init (&render->subtitle_segment, GST_FORMAT_TIME);
gst_video_info_init (&render->info);
break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
case GST_STATE_CHANGE_READY_TO_NULL:
default:
break;
}
return ret;
}
static gboolean gst_imx_blitter_video_transform_decide_allocation(GstBaseTransform *transform, GstQuery *query)
{
GstImxBlitterVideoTransform *blitter_video_transform = GST_IMX_BLITTER_VIDEO_TRANSFORM(transform);
GstCaps *outcaps;
GstBufferPool *pool = NULL;
guint size, min = 0, max = 0;
GstStructure *config;
GstVideoInfo vinfo;
gboolean update_pool;
g_assert(blitter_video_transform->blitter != NULL);
gst_query_parse_allocation(query, &outcaps, NULL);
gst_video_info_init(&vinfo);
gst_video_info_from_caps(&vinfo, outcaps);
GST_DEBUG_OBJECT(blitter_video_transform, "num allocation pools: %d", gst_query_get_n_allocation_pools(query));
/* Look for an allocator which can allocate physical memory buffers */
if (gst_query_get_n_allocation_pools(query) > 0)
{
for (guint i = 0; i < gst_query_get_n_allocation_pools(query); ++i)
{
gst_query_parse_nth_allocation_pool(query, i, &pool, &size, &min, &max);
if (gst_buffer_pool_has_option(pool, GST_BUFFER_POOL_OPTION_IMX_PHYS_MEM))
break;
}
size = MAX(size, vinfo.size);
update_pool = TRUE;
}
else
{
pool = NULL;
size = vinfo.size;
min = max = 0;
update_pool = FALSE;
}
/* Either no pool or no pool with the ability to allocate physical memory buffers
* has been found -> create a new pool */
if ((pool == NULL) || !gst_buffer_pool_has_option(pool, GST_BUFFER_POOL_OPTION_IMX_PHYS_MEM))
{
if (pool == NULL)
GST_DEBUG_OBJECT(blitter_video_transform, "no pool present; creating new pool");
else
GST_DEBUG_OBJECT(blitter_video_transform, "no pool supports physical memory buffers; creating new pool");
pool = gst_imx_base_blitter_create_bufferpool(blitter_video_transform->blitter, outcaps, size, min, max, NULL, NULL);
}
else
{
config = gst_buffer_pool_get_config(pool);
gst_buffer_pool_config_set_params(config, outcaps, size, min, max);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_IMX_PHYS_MEM);
gst_buffer_pool_config_add_option(config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_set_config(pool, config);
}
GST_DEBUG_OBJECT(
blitter_video_transform,
"pool config: outcaps: %" GST_PTR_FORMAT " size: %u min buffers: %u max buffers: %u",
(gpointer)outcaps,
size,
min,
max
);
if (update_pool)
gst_query_set_nth_allocation_pool(query, 0, pool, size, min, max);
else
gst_query_add_allocation_pool(query, pool, size, min, max);
if (pool != NULL)
gst_object_unref(pool);
return TRUE;
}
void gst_imx_blitter_init(GstImxBlitter *blitter)
{
GST_TRACE_OBJECT(blitter, "initializing blitter base");
blitter->dma_bufferpool = NULL;
gst_video_info_init(&(blitter->input_video_info));
}
static gboolean
gst_genicamsrc_start (GstBaseSrc * bsrc)
{
GstGenicamSrc *src = GST_GENICAM_SRC (bsrc);
GC_ERROR ret;
uint32_t i, num_ifaces, num_devs;
guint32 width, height, bpp, stride;
GstVideoInfo vinfo;
GST_DEBUG_OBJECT (src, "start");
/* bind functions from CTI */
if (!gst_genicamsrc_bind_functions (src)) {
GST_ELEMENT_ERROR (src, LIBRARY, INIT,
("GenTL CTI could not be opened: %s", g_module_error ()), (NULL));
return FALSE;
}
/* initialize library and print info */
ret = GTL_GCInitLib ();
HANDLE_GTL_ERROR ("GenTL Producer library could not be initialized");
gst_genicam_print_gentl_impl_info (src);
/* open GenTL, print info, and update interface list */
ret = GTL_TLOpen (&src->hTL);
HANDLE_GTL_ERROR ("System module failed to open");
gst_genicam_print_system_info (src);
ret = GTL_TLUpdateInterfaceList (src->hTL, NULL, src->timeout);
HANDLE_GTL_ERROR ("Failed to update interface list within timeout");
/* print info for all interfaces and open specified interface */
ret = GTL_TLGetNumInterfaces (src->hTL, &num_ifaces);
HANDLE_GTL_ERROR ("Failed to get number of interfaces");
if (num_ifaces > 0) {
GST_DEBUG_OBJECT (src, "Found %dGenTL interfaces", num_ifaces);
for (i = 0; i < num_ifaces; ++i) {
gst_genicam_print_interface_info (src, i);
}
} else {
GST_ELEMENT_ERROR (src, LIBRARY, FAILED, ("No interfaces found"), (NULL));
goto error;
}
if (!src->interface_id || src->interface_id[0] == 0) {
size_t id_size;
GST_DEBUG_OBJECT (src, "Trying to find interface ID at index %d",
src->interface_index);
ret = GTL_TLGetInterfaceID (src->hTL, src->interface_index, NULL, &id_size);
HANDLE_GTL_ERROR ("Failed to get interface ID at specified index");
if (src->interface_id) {
g_free (src->interface_id);
}
src->interface_id = (gchar *) g_malloc (id_size);
ret =
GTL_TLGetInterfaceID (src->hTL, src->interface_index, src->interface_id,
&id_size);
HANDLE_GTL_ERROR ("Failed to get interface ID at specified index");
}
GST_DEBUG_OBJECT (src, "Trying to open interface '%s'", src->interface_id);
ret = GTL_TLOpenInterface (src->hTL, src->interface_id, &src->hIF);
HANDLE_GTL_ERROR ("Interface module failed to open");
ret = GTL_IFUpdateDeviceList (src->hIF, NULL, src->timeout);
HANDLE_GTL_ERROR ("Failed to update device list within timeout");
/* print info for all devices and open specified device */
ret = GTL_IFGetNumDevices (src->hIF, &num_devs);
HANDLE_GTL_ERROR ("Failed to get number of devices");
if (num_devs > 0) {
for (i = 0; i < num_devs; ++i) {
gst_genicam_print_device_info (src, i);
}
} else {
GST_ELEMENT_ERROR (src, LIBRARY, FAILED,
("No devices found on interface"), (NULL));
goto error;
}
if (!src->device_id || src->device_id[0] == 0) {
size_t id_size;
GST_DEBUG_OBJECT (src, "Trying to find device ID at index %d",
src->device_index);
GTL_IFGetDeviceID (src->hIF, src->device_index, NULL, &id_size);
HANDLE_GTL_ERROR ("Failed to get device ID at specified index");
if (src->device_id) {
g_free (src->device_id);
}
src->device_id = (gchar *) g_malloc (id_size);
GTL_IFGetDeviceID (src->hIF, src->device_index, src->device_id, &id_size);
HANDLE_GTL_ERROR ("Failed to get device ID at specified index");
}
GST_DEBUG_OBJECT (src, "Trying to open device '%s'", src->device_id);
ret =
GTL_IFOpenDevice (src->hIF, src->device_id, DEVICE_ACCESS_CONTROL,
&src->hDEV);
HANDLE_GTL_ERROR ("Failed to open device");
/* find and open specified data stream id */
if (!src->stream_id || src->stream_id[0] == 0) {
size_t id_size;
GST_DEBUG_OBJECT (src, "Trying to find stream ID at index %d",
src->stream_index);
GTL_DevGetDataStreamID (src->hDEV, src->stream_index, NULL, &id_size);
HANDLE_GTL_ERROR ("Failed to get stream ID at specified index");
if (src->stream_id) {
g_free (src->stream_id);
}
src->stream_id = (gchar *) g_malloc (id_size);
GTL_DevGetDataStreamID (src->hDEV, src->stream_index, src->stream_id,
&id_size);
HANDLE_GTL_ERROR ("Failed to get stream ID at specified index");
}
GST_DEBUG_OBJECT (src, "Trying to open data stream '%s'", src->stream_id);
ret = GTL_DevOpenDataStream (src->hDEV, src->stream_id, &src->hDS);
HANDLE_GTL_ERROR ("Failed to open data stream");
{
uint32_t num_urls = 0;
char url[2048];
size_t url_len = sizeof (url);
INFO_DATATYPE datatype;
const uint32_t url_index = 0;
ret = GTL_DevGetPort (src->hDEV, &src->hDevPort);
HANDLE_GTL_ERROR ("Failed to get port on device");
ret = GTL_GCGetNumPortURLs (src->hDevPort, &num_urls);
HANDLE_GTL_ERROR ("Failed to get number of port URLs");
GST_DEBUG_OBJECT (src, "Found %d port URLs", num_urls);
GST_DEBUG_OBJECT (src, "Trying to get URL index %d", url_index);
GTL_GCGetPortURLInfo (src->hDevPort, url_index, URL_INFO_URL, &datatype,
url, &url_len);
HANDLE_GTL_ERROR ("Failed to get URL");
GST_DEBUG_OBJECT (src, "Found URL '%s'", url);
g_assert (url_len > 6);
if (g_str_has_prefix (url, "file")) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("file url not supported yet"), (NULL));
goto error;
} else if (g_str_has_prefix (url, "local")) {
GError *err = NULL;
GMatchInfo *matchInfo;
GRegex *regex;
gchar *filename, *addr_str, *len_str;
uint64_t addr;
size_t len;
gchar *buf;
regex =
g_regex_new
("local:(?:///)?(?<filename>[^;]+);(?<address>[^;]+);(?<length>[^?]+)(?:[?]SchemaVersion=([^&]+))?",
(GRegexCompileFlags) 0, (GRegexMatchFlags) 0, &err);
if (!regex) {
goto error;
}
g_regex_match (regex, url, (GRegexMatchFlags) 0, &matchInfo);
filename = g_match_info_fetch_named (matchInfo, "filename");
addr_str = g_match_info_fetch_named (matchInfo, "address");
len_str = g_match_info_fetch_named (matchInfo, "length");
if (!filename || !addr_str || !len_str) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to parse local URL"), (NULL));
goto error;
}
addr = g_ascii_strtoull (addr_str, NULL, 16);
len = g_ascii_strtoull (len_str, NULL, 16);
buf = (gchar *) g_malloc (len);
GTL_GCReadPort (src->hDevPort, addr, buf, &len);
HANDLE_GTL_ERROR ("Failed to read XML from port");
if (g_str_has_suffix (filename, "zip")) {
gchar *zipfilepath;
unzFile uf;
unz_file_info64 fileinfo;
gchar xmlfilename[2048];
gchar *xml;
zipfilepath = g_build_filename (g_get_tmp_dir (), filename, NULL);
if (!g_file_set_contents (zipfilepath, buf, len, &err)) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to write zipped XML to %s", zipfilepath), (NULL));
goto error;
}
uf = unzOpen64 (zipfilepath);
if (!uf) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to open zipped XML %s", zipfilepath), (NULL));
goto error;
}
//ret = unzGetGlobalInfo64(uf, &gi);
ret =
unzGetCurrentFileInfo64 (uf, &fileinfo, xmlfilename,
sizeof (xmlfilename), NULL, 0, NULL, 0);
if (ret != UNZ_OK) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to query zip file %s", zipfilepath), (NULL));
goto error;
}
ret = unzOpenCurrentFile (uf);
if (ret != UNZ_OK) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to extract file %s", xmlfilename), (NULL));
goto error;
}
xml = (gchar *) g_malloc (fileinfo.uncompressed_size);
if (!xml) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to allocate memory to extract XML file"), (NULL));
goto error;
}
ret = unzReadCurrentFile (uf, xml, fileinfo.uncompressed_size);
if (ret != fileinfo.uncompressed_size) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("Failed to extract XML file %s", xmlfilename), (NULL));
goto error;
}
unzClose (uf);
g_free (zipfilepath);
zipfilepath = g_build_filename (g_get_tmp_dir (), xmlfilename, NULL);
g_file_set_contents (zipfilepath, xml, fileinfo.uncompressed_size,
&err);
g_free (zipfilepath);
g_free (xml);
//GZlibDecompressor *decompress;
//char *unzipped;
//gsize outbuf_size, bytes_read, bytes_written;
//GInputStream *zippedstream, *unzippedstream;
//decompress = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB);
////zippedstream = g_memory_input_stream_new_from_data(buf, len, g_free);
////unzippedstream = g_converter_input_stream_new (zippedstream, G_CONVERTER(decompress));
////g_input_stream_read_all (G_INPUT_STREAM(unzippedstream),
//// g_converter_output_stream
//outbuf_size = 10000000;
//unzipped = (gchar*) g_malloc(outbuf_size);
//g_converter_convert (G_CONVERTER (decompress), buf, len, unzipped, outbuf_size, G_CONVERTER_NO_FLAGS, &bytes_read, &bytes_written, &err);
//GST_DEBUG_OBJECT (src, unzipped);
}
g_free (filename);
g_free (addr_str);
g_free (len_str);
g_free (buf);
} else if (g_str_has_prefix (url, "http")) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY,
("file url not supported yet"), (NULL));
goto error;
}
}
{
// TODO: use Genicam node map for this
guint32 val = 0;
size_t datasize = 4;
ret = GTL_GCReadPort (src->hDevPort, 0x30204, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to get width");
width = GUINT32_FROM_BE (val);
ret = GTL_GCReadPort (src->hDevPort, 0x30224, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to get height");
height = GUINT32_FROM_BE (val);
bpp = 8;
}
if (!gst_genicamsrc_prepare_buffers (src)) {
GST_ELEMENT_ERROR (src, RESOURCE, TOO_LAZY, ("Failed to prepare buffers"),
(NULL));
goto error;
}
{
ret =
GTL_GCRegisterEvent (src->hDS, EVENT_NEW_BUFFER, &src->hNewBufferEvent);
HANDLE_GTL_ERROR ("Failed to register New Buffer event");
}
ret =
GTL_DSStartAcquisition (src->hDS, ACQ_START_FLAGS_DEFAULT,
GENTL_INFINITE);
HANDLE_GTL_ERROR ("Failed to start stream acquisition");
{
// TODO: use Genicam node map for this
guint32 val;
size_t datasize;
/* set AcquisitionMode to Continuous */
val = GUINT32_TO_BE (2);
datasize = sizeof (val);
ret = GTL_GCWritePort (src->hDevPort, 0x40004, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to start device acquisition");
/* send AcquisitionStart command */
val = GUINT32_TO_BE (1);
datasize = sizeof (val);
ret = GTL_GCWritePort (src->hDevPort, 0x40024, &val, &datasize);
HANDLE_GTL_ERROR ("Failed to start device acquisition");
}
/* create caps */
if (src->caps) {
gst_caps_unref (src->caps);
src->caps = NULL;
}
gst_video_info_init (&vinfo);
if (bpp <= 8) {
gst_video_info_set_format (&vinfo, GST_VIDEO_FORMAT_GRAY8, width, height);
src->caps = gst_video_info_to_caps (&vinfo);
} else if (bpp > 8 && bpp <= 16) {
GValue val = G_VALUE_INIT;
GstStructure *s;
if (G_BYTE_ORDER == G_LITTLE_ENDIAN) {
gst_video_info_set_format (&vinfo, GST_VIDEO_FORMAT_GRAY16_LE, width,
height);
} else if (G_BYTE_ORDER == G_BIG_ENDIAN) {
gst_video_info_set_format (&vinfo, GST_VIDEO_FORMAT_GRAY16_BE, width,
height);
}
src->caps = gst_video_info_to_caps (&vinfo);
/* set bpp, extra info for GRAY16 so elements can scale properly */
s = gst_caps_get_structure (src->caps, 0);
g_value_init (&val, G_TYPE_INT);
g_value_set_int (&val, bpp);
gst_structure_set_value (s, "bpp", &val);
g_value_unset (&val);
} else {
GST_ELEMENT_ERROR (src, STREAM, WRONG_TYPE,
("Unknown or unsupported bit depth (%d).", bpp), (NULL));
return FALSE;
}
src->height = vinfo.height;
src->gst_stride = GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0);
GST_DEBUG_OBJECT (src, "starting acquisition");
//TODO: start acquisition engine
/* TODO: check timestamps on buffers vs start time */
src->acq_start_time =
gst_clock_get_time (gst_element_get_clock (GST_ELEMENT (src)));
return TRUE;
error:
if (src->hDS) {
GTL_DSClose (src->hDS);
src->hDS = NULL;
}
if (src->hDEV) {
GTL_DevClose (src->hDEV);
src->hDEV = NULL;
}
if (src->hIF) {
GTL_IFClose (src->hIF);
src->hIF = NULL;
}
if (src->hTL) {
GTL_TLClose (src->hTL);
src->hTL = NULL;
}
GTL_GCCloseLib ();
return FALSE;
}
/**
* gst_niimaqsrc_get_cam_caps:
* src: #GstNiImaq instance
*
* Get caps of camera attached to open IMAQ interface
*
* Returns: the #GstCaps of the src pad. Unref the caps when you no longer need it.
*/
GstCaps *
gst_niimaqsrc_get_cam_caps (GstNiImaqSrc * src)
{
GstCaps *gcaps = NULL;
Int32 rval;
uInt32 val;
gint depth, bpp;
GstVideoInfo vinfo;
if (!src->iid) {
GST_ELEMENT_ERROR (src, RESOURCE, FAILED,
("Camera interface not open"), ("Camera interface not open"));
goto error;
}
gst_video_info_init (&vinfo);
GST_LOG_OBJECT (src, "Retrieving attributes from IMAQ interface");
rval = imgGetAttribute (src->iid, IMG_ATTR_BITSPERPIXEL, &val);
gst_niimaqsrc_report_imaq_error (rval);
bpp = val;
rval &= imgGetAttribute (src->iid, IMG_ATTR_BYTESPERPIXEL, &val);
gst_niimaqsrc_report_imaq_error (rval);
depth = val * 8;
rval &= imgGetAttribute (src->iid, IMG_ATTR_ROI_WIDTH, &val);
gst_niimaqsrc_report_imaq_error (rval);
vinfo.width = val;
rval &= imgGetAttribute (src->iid, IMG_ATTR_ROI_HEIGHT, &val);
gst_niimaqsrc_report_imaq_error (rval);
vinfo.height = val;
if (rval) {
GST_ELEMENT_ERROR (src, STREAM, FAILED,
("attempt to read attributes failed"),
("attempt to read attributes failed"));
goto error;
}
if (depth == 8)
vinfo.finfo = gst_video_format_get_info (GST_VIDEO_FORMAT_GRAY8);
else if (depth == 16)
vinfo.finfo = gst_video_format_get_info (GST_VIDEO_FORMAT_GRAY16_LE);
else if (depth == 32)
vinfo.finfo = gst_video_format_get_info (GST_VIDEO_FORMAT_BGRA);
else {
GST_ERROR_OBJECT (src, "Depth %d (%d-bit) not supported yet", depth, bpp);
goto error;
}
vinfo.fps_n = 30;
vinfo.fps_d = 1;
/* hard code framerate and par as IMAQ doesn't tell us anything about it */
gcaps = gst_video_info_to_caps (&vinfo);
GST_LOG_OBJECT (src, "the camera caps are %" GST_PTR_FORMAT, gcaps);
return gcaps;
error:
if (gcaps) {
gst_caps_unref (gcaps);
}
return NULL;
}
bool ofGstVideoPlayer::allocate(){
if(bIsAllocated){
return true;
}
guint64 durationNanos = videoUtils.getDurationNanos();
nFrames = 0;
if(GstPad* pad = gst_element_get_static_pad(videoUtils.getSink(), "sink")){
#if GST_VERSION_MAJOR==0
int width,height;
if(gst_video_get_size(GST_PAD(pad), &width, &height)){
if(!videoUtils.allocate(width,height,internalPixelFormat)) return false;
}else{
ofLogError("ofGstVideoPlayer") << "allocate(): couldn't query width and height";
return false;
}
const GValue *framerate = gst_video_frame_rate(pad);
fps_n=0;
fps_d=0;
if(framerate && GST_VALUE_HOLDS_FRACTION (framerate)){
fps_n = gst_value_get_fraction_numerator (framerate);
fps_d = gst_value_get_fraction_denominator (framerate);
nFrames = (float)(durationNanos / (float)GST_SECOND) * (float)fps_n/(float)fps_d;
ofLogVerbose("ofGstVideoPlayer") << "allocate(): framerate: " << fps_n << "/" << fps_d;
}else{
ofLogWarning("ofGstVideoPlayer") << "allocate(): cannot get framerate, frame seek won't work";
}
bIsAllocated = true;
#else
if(GstCaps *caps = gst_pad_get_current_caps (GST_PAD (pad))){
GstVideoInfo info;
gst_video_info_init (&info);
if (gst_video_info_from_caps (&info, caps)){
ofPixelFormat format = ofGstVideoUtils::getOFFormat(GST_VIDEO_INFO_FORMAT(&info));
if(format!=internalPixelFormat){
ofLogVerbose("ofGstVideoPlayer") << "allocating as " << info.width << "x" << info.height << " " << info.finfo->description << " " << info.finfo->name;
internalPixelFormat = format;
}
if(!videoUtils.allocate(info.width,info.height,format)) return false;
}else{
ofLogError("ofGstVideoPlayer") << "allocate(): couldn't query width and height";
return false;
}
fps_n = info.fps_n;
fps_d = info.fps_d;
nFrames = (float)(durationNanos / (float)GST_SECOND) * (float)fps_n/(float)fps_d;
gst_caps_unref(caps);
bIsAllocated = true;
}else{
ofLogError("ofGstVideoPlayer") << "allocate(): cannot get pipeline caps";
bIsAllocated = false;
}
#endif
gst_object_unref(GST_OBJECT(pad));
}else{
ofLogError("ofGstVideoPlayer") << "allocate(): cannot get sink pad";
bIsAllocated = false;
}
return bIsAllocated;
}
static GstFlowReturn
gst_gdk_pixbuf_dec_flush (GstGdkPixbufDec * filter)
{
GstBuffer *outbuf;
GdkPixbuf *pixbuf;
int y;
guint8 *out_pix;
guint8 *in_pix;
int in_rowstride, out_rowstride;
GstFlowReturn ret;
GstCaps *caps = NULL;
gint width, height;
gint n_channels;
GstVideoFrame frame;
pixbuf = gdk_pixbuf_loader_get_pixbuf (filter->pixbuf_loader);
if (pixbuf == NULL)
goto no_pixbuf;
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
if (GST_VIDEO_INFO_FORMAT (&filter->info) == GST_VIDEO_FORMAT_UNKNOWN) {
GstVideoInfo info;
GstVideoFormat fmt;
GST_DEBUG ("Set size to %dx%d", width, height);
n_channels = gdk_pixbuf_get_n_channels (pixbuf);
switch (n_channels) {
case 3:
fmt = GST_VIDEO_FORMAT_RGB;
break;
case 4:
fmt = GST_VIDEO_FORMAT_RGBA;
break;
default:
goto channels_not_supported;
}
gst_video_info_init (&info);
gst_video_info_set_format (&info, fmt, width, height);
info.fps_n = filter->in_fps_n;
info.fps_d = filter->in_fps_d;
caps = gst_video_info_to_caps (&info);
filter->info = info;
gst_pad_set_caps (filter->srcpad, caps);
gst_caps_unref (caps);
gst_gdk_pixbuf_dec_setup_pool (filter, &info);
}
ret = gst_buffer_pool_acquire_buffer (filter->pool, &outbuf, NULL);
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);
gst_video_frame_map (&frame, &filter->info, outbuf, GST_MAP_WRITE);
out_pix = GST_VIDEO_FRAME_PLANE_DATA (&frame, 0);
out_rowstride = GST_VIDEO_FRAME_PLANE_STRIDE (&frame, 0);
for (y = 0; y < height; y++) {
memcpy (out_pix, in_pix, width * GST_VIDEO_FRAME_COMP_PSTRIDE (&frame, 0));
in_pix += in_rowstride;
out_pix += out_rowstride;
}
gst_video_frame_unmap (&frame);
GST_DEBUG ("pushing... %" G_GSIZE_FORMAT " bytes",
gst_buffer_get_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 gboolean
gst_gl_mixer_decide_allocation (GstGLMixer * mix, GstQuery * query)
{
GstGLMixerClass *mixer_class = GST_GL_MIXER_GET_CLASS (mix);
GstBufferPool *pool = NULL;
GstStructure *config;
GstCaps *caps;
guint min, max, size;
gboolean update_pool;
GError *error = NULL;
guint idx;
guint out_width, out_height;
GstGLContext *other_context = NULL;
GstVideoAggregator *vagg = GST_VIDEO_AGGREGATOR (mix);
gst_query_parse_allocation (query, &caps, NULL);
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
update_pool = TRUE;
} else {
GstVideoInfo vinfo;
gst_video_info_init (&vinfo);
gst_video_info_from_caps (&vinfo, caps);
size = vinfo.size;
min = max = 0;
update_pool = FALSE;
}
if (!gst_gl_ensure_display (mix, &mix->display))
return FALSE;
if (gst_query_find_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, &idx)) {
GstGLContext *context;
const GstStructure *upload_meta_params;
gpointer handle;
gchar *type;
gchar *apis;
gst_query_parse_nth_allocation_meta (query, idx, &upload_meta_params);
if (upload_meta_params) {
if (gst_structure_get (upload_meta_params, "gst.gl.GstGLContext",
GST_GL_TYPE_CONTEXT, &context, NULL) && context) {
GstGLContext *old = mix->context;
mix->context = context;
if (old)
gst_object_unref (old);
} else if (gst_structure_get (upload_meta_params, "gst.gl.context.handle",
G_TYPE_POINTER, &handle, "gst.gl.context.type", G_TYPE_STRING,
&type, "gst.gl.context.apis", G_TYPE_STRING, &apis, NULL)
&& handle) {
GstGLPlatform platform = GST_GL_PLATFORM_NONE;
GstGLAPI gl_apis;
GST_DEBUG ("got GL context handle 0x%p with type %s and apis %s",
handle, type, apis);
platform = gst_gl_platform_from_string (type);
gl_apis = gst_gl_api_from_string (apis);
if (gl_apis && platform)
other_context =
gst_gl_context_new_wrapped (mix->display, (guintptr) handle,
platform, gl_apis);
}
}
}
if (!mix->context) {
mix->context = gst_gl_context_new (mix->display);
if (!gst_gl_context_create (mix->context, other_context, &error))
goto context_error;
}
out_width = GST_VIDEO_INFO_WIDTH (&vagg->info);
out_height = GST_VIDEO_INFO_HEIGHT (&vagg->info);
g_mutex_lock (&mix->priv->gl_resource_lock);
mix->priv->gl_resource_ready = FALSE;
if (mix->fbo) {
gst_gl_context_del_fbo (mix->context, mix->fbo, mix->depthbuffer);
mix->fbo = 0;
mix->depthbuffer = 0;
}
if (!gst_gl_context_gen_fbo (mix->context, out_width, out_height,
&mix->fbo, &mix->depthbuffer)) {
g_cond_signal (&mix->priv->gl_resource_cond);
g_mutex_unlock (&mix->priv->gl_resource_lock);
goto context_error;
}
if (mix->out_tex_id)
gst_gl_context_del_texture (mix->context, &mix->out_tex_id);
gst_gl_context_gen_texture (mix->context, &mix->out_tex_id,
GST_VIDEO_FORMAT_RGBA, out_width, out_height);
if (mixer_class->set_caps)
mixer_class->set_caps (mix, caps);
mix->priv->gl_resource_ready = TRUE;
g_cond_signal (&mix->priv->gl_resource_cond);
g_mutex_unlock (&mix->priv->gl_resource_lock);
if (!pool)
pool = gst_gl_buffer_pool_new (mix->context);
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_set_config (pool, config);
if (update_pool)
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
else
gst_query_add_allocation_pool (query, pool, size, min, max);
gst_object_unref (pool);
return TRUE;
context_error:
{
GST_ELEMENT_ERROR (mix, RESOURCE, NOT_FOUND, ("%s", error->message),
(NULL));
return FALSE;
}
}
GstBuffer *
gst_core_video_buffer_new (GstCoreMediaCtx * ctx, CVBufferRef cvbuf,
GstVideoInfo * vinfo)
{
GstCVApi *cv = ctx->cv;
void *data;
size_t size;
CVPixelBufferRef pixbuf = NULL;
GstBuffer *buf;
GstCoreVideoMeta *meta;
guint width, height, n_planes, i;
gsize offset[GST_VIDEO_MAX_PLANES];
gint stride[GST_VIDEO_MAX_PLANES];
if (CFGetTypeID (cvbuf) != cv->CVPixelBufferGetTypeID ())
/* TODO: Do we need to handle other buffer types? */
goto error;
pixbuf = (CVPixelBufferRef) cvbuf;
if (cv->CVPixelBufferLockBaseAddress (pixbuf,
kCVPixelBufferLock_ReadOnly) != kCVReturnSuccess) {
goto error;
}
buf = gst_buffer_new ();
/* add the corevideo meta to free the underlying corevideo buffer */
meta = (GstCoreVideoMeta *) gst_buffer_add_meta (buf,
gst_core_video_meta_get_info (), NULL);
meta->ctx = g_object_ref (ctx);
meta->cvbuf = cv->CVBufferRetain (cvbuf);
meta->pixbuf = pixbuf;
/* set stride, offset and size */
memset (&offset, 0, sizeof (offset));
memset (&stride, 0, sizeof (stride));
data = cv->CVPixelBufferGetBaseAddress (pixbuf);
height = cv->CVPixelBufferGetHeight (pixbuf);
if (cv->CVPixelBufferIsPlanar (pixbuf)) {
GstVideoInfo tmp_vinfo;
n_planes = cv->CVPixelBufferGetPlaneCount (pixbuf);
for (i = 0; i < n_planes; ++i)
stride[i] = cv->CVPixelBufferGetBytesPerRowOfPlane (pixbuf, i);
/* FIXME: don't hardcode NV12 */
gst_video_info_init (&tmp_vinfo);
gst_video_info_set_format (&tmp_vinfo,
GST_VIDEO_FORMAT_NV12, stride[0], height);
offset[1] = tmp_vinfo.offset[1];
size = tmp_vinfo.size;
} else {
n_planes = 1;
size = cv->CVPixelBufferGetBytesPerRow (pixbuf) * height;
}
gst_buffer_append_memory (buf,
gst_memory_new_wrapped (GST_MEMORY_FLAG_NO_SHARE, data,
size, 0, size, NULL, NULL));
if (vinfo) {
GstVideoMeta *video_meta;
width = vinfo->width;
video_meta =
gst_buffer_add_video_meta_full (buf, GST_VIDEO_FRAME_FLAG_NONE,
GST_VIDEO_FORMAT_NV12, width, height, n_planes, offset, stride);
}
return buf;
error:
return NULL;
}
static gboolean
gst_vtdec_sink_setcaps (GstVTDec * self, GstCaps * caps)
{
GstStructure *structure;
CMFormatDescriptionRef fmt_desc = NULL;
GstVideoFormat format = GST_VIDEO_FORMAT_NV12;
gint width, height;
gint fps_n, fps_d;
gint par_n, par_d;
structure = gst_caps_get_structure (caps, 0);
if (!gst_structure_get_int (structure, "width", &width))
goto incomplete_caps;
if (!gst_structure_get_int (structure, "height", &height))
goto incomplete_caps;
gst_video_info_init (&self->vinfo);
gst_video_info_set_format (&self->vinfo, format, width, height);
if (gst_structure_get_fraction (structure, "framerate", &fps_n, &fps_d)) {
if (fps_n == 0) {
/* variable framerate */
self->vinfo.flags |= GST_VIDEO_FLAG_VARIABLE_FPS;
/* see if we have a max-framerate */
gst_structure_get_fraction (structure, "max-framerate", &fps_n, &fps_d);
}
self->vinfo.fps_n = fps_n;
self->vinfo.fps_d = fps_d;
} else {
/* unspecified is variable framerate */
self->vinfo.fps_n = 0;
self->vinfo.fps_d = 1;
}
if (gst_structure_get_fraction (structure, "pixel-aspect-ratio",
&par_n, &par_d)) {
self->vinfo.par_n = par_n;
self->vinfo.par_d = par_d;
} else {
self->vinfo.par_n = 1;
self->vinfo.par_d = 1;
}
if (self->details->format_id == kVTFormatH264) {
const GValue *codec_data_value;
codec_data_value = gst_structure_get_value (structure, "codec_data");
if (codec_data_value != NULL) {
fmt_desc = gst_vtdec_create_format_description_from_codec_data (self,
gst_value_get_buffer (codec_data_value));
} else {
GST_DEBUG_OBJECT (self, "no codec_data in caps, awaiting future setcaps");
}
} else {
fmt_desc = gst_vtdec_create_format_description (self);
}
if (fmt_desc != NULL) {
gst_vtdec_destroy_session (self, &self->session);
self->ctx->cm->FigFormatDescriptionRelease (self->fmt_desc);
self->fmt_desc = fmt_desc;
self->session = gst_vtdec_create_session (self, fmt_desc);
if (self->session == NULL)
goto session_create_error;
}
/* renegotiate when upstream caps change */
gst_pad_mark_reconfigure (self->srcpad);
return TRUE;
/* ERRORS */
incomplete_caps:
{
return TRUE;
}
session_create_error:
{
GST_ELEMENT_ERROR (self, RESOURCE, FAILED,
("failed to create session"), (NULL));
return FALSE;
}
}
static gboolean
gst_gl_test_src_decide_allocation (GstBaseSrc * basesrc, GstQuery * query)
{
GstGLTestSrc *src = GST_GL_TEST_SRC (basesrc);
GstBufferPool *pool = NULL;
GstStructure *config;
GstCaps *caps;
guint min, max, size;
gboolean update_pool;
GError *error = NULL;
if (!gst_gl_ensure_element_data (src, &src->display, &src->other_context))
return FALSE;
gst_gl_display_filter_gl_api (src->display, SUPPORTED_GL_APIS);
_find_local_gl_context (src);
if (!src->context) {
GST_OBJECT_LOCK (src->display);
do {
if (src->context) {
gst_object_unref (src->context);
src->context = NULL;
}
/* just get a GL context. we don't care */
src->context =
gst_gl_display_get_gl_context_for_thread (src->display, NULL);
if (!src->context) {
if (!gst_gl_display_create_context (src->display, src->other_context,
&src->context, &error)) {
GST_OBJECT_UNLOCK (src->display);
goto context_error;
}
}
} while (!gst_gl_display_add_context (src->display, src->context));
GST_OBJECT_UNLOCK (src->display);
}
if ((gst_gl_context_get_gl_api (src->context) & SUPPORTED_GL_APIS) == 0)
goto unsupported_gl_api;
gst_gl_context_thread_add (src->context,
(GstGLContextThreadFunc) _src_generate_fbo_gl, src);
if (!src->fbo)
goto context_error;
gst_query_parse_allocation (query, &caps, NULL);
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
update_pool = TRUE;
} else {
GstVideoInfo vinfo;
gst_video_info_init (&vinfo);
gst_video_info_from_caps (&vinfo, caps);
size = vinfo.size;
min = max = 0;
update_pool = FALSE;
}
if (!pool || !GST_IS_GL_BUFFER_POOL (pool)) {
/* can't use this pool */
if (pool)
gst_object_unref (pool);
pool = gst_gl_buffer_pool_new (src->context);
}
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
if (gst_query_find_allocation_meta (query, GST_GL_SYNC_META_API_TYPE, NULL))
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_GL_SYNC_META);
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META);
gst_buffer_pool_set_config (pool, config);
if (update_pool)
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
else
gst_query_add_allocation_pool (query, pool, size, min, max);
gst_gl_test_src_init_shader (src);
gst_object_unref (pool);
return TRUE;
unsupported_gl_api:
{
GstGLAPI gl_api = gst_gl_context_get_gl_api (src->context);
gchar *gl_api_str = gst_gl_api_to_string (gl_api);
gchar *supported_gl_api_str = gst_gl_api_to_string (SUPPORTED_GL_APIS);
GST_ELEMENT_ERROR (src, RESOURCE, BUSY,
("GL API's not compatible context: %s supported: %s", gl_api_str,
supported_gl_api_str), (NULL));
g_free (supported_gl_api_str);
g_free (gl_api_str);
return FALSE;
}
context_error:
{
GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, ("%s", error->message),
(NULL));
g_clear_error (&error);
if (src->context)
gst_object_unref (src->context);
src->context = NULL;
return FALSE;
}
}
static gboolean
gst_gl_filter_decide_allocation (GstBaseTransform * trans, GstQuery * query)
{
GstGLFilter *filter = GST_GL_FILTER (trans);
GstGLFilterClass *filter_class = GST_GL_FILTER_GET_CLASS (filter);
GstBufferPool *pool = NULL;
GstStructure *config;
GstCaps *caps;
guint min, max, size;
gboolean update_pool;
guint idx;
GError *error = NULL;
guint in_width, in_height, out_width, out_height;
gst_query_parse_allocation (query, &caps, NULL);
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
update_pool = TRUE;
} else {
GstVideoInfo vinfo;
gst_video_info_init (&vinfo);
gst_video_info_from_caps (&vinfo, caps);
size = vinfo.size;
min = max = 0;
update_pool = FALSE;
}
if (!gst_gl_ensure_display (filter, &filter->display))
return FALSE;
if (gst_query_find_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, &idx)) {
GstGLContext *context;
const GstStructure *upload_meta_params;
gst_query_parse_nth_allocation_meta (query, idx, &upload_meta_params);
if (gst_structure_get (upload_meta_params, "gst.gl.GstGLContext",
GST_GL_TYPE_CONTEXT, &context, NULL) && context) {
GstGLContext *old = filter->context;
filter->context = context;
if (old)
gst_object_unref (old);
}
}
if (!filter->context) {
filter->context = gst_gl_context_new (filter->display);
if (!gst_gl_context_create (filter->context, filter->other_context, &error))
goto context_error;
}
in_width = GST_VIDEO_INFO_WIDTH (&filter->in_info);
in_height = GST_VIDEO_INFO_HEIGHT (&filter->in_info);
out_width = GST_VIDEO_INFO_WIDTH (&filter->out_info);
out_height = GST_VIDEO_INFO_HEIGHT (&filter->out_info);
if (!filter->upload) {
filter->upload = gst_gl_upload_new (filter->context);
gst_gl_upload_init_format (filter->upload, filter->in_info,
filter->out_info);
}
//blocking call, generate a FBO
if (!gst_gl_context_gen_fbo (filter->context, out_width, out_height,
&filter->fbo, &filter->depthbuffer))
goto context_error;
gst_gl_context_gen_texture (filter->context, &filter->in_tex_id,
GST_VIDEO_FORMAT_RGBA, in_width, in_height);
gst_gl_context_gen_texture (filter->context, &filter->out_tex_id,
GST_VIDEO_FORMAT_RGBA, out_width, out_height);
if (filter_class->display_init_cb != NULL) {
gst_gl_context_thread_add (filter->context, gst_gl_filter_start_gl, filter);
}
if (filter_class->onInitFBO) {
if (!filter_class->onInitFBO (filter))
goto error;
}
if (!pool)
pool = gst_gl_buffer_pool_new (filter->context);
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_VIDEO_META);
gst_buffer_pool_set_config (pool, config);
if (update_pool)
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
else
gst_query_add_allocation_pool (query, pool, size, min, max);
gst_object_unref (pool);
return TRUE;
context_error:
{
GST_ELEMENT_ERROR (trans, RESOURCE, NOT_FOUND, ("%s", error->message),
(NULL));
return FALSE;
}
error:
{
GST_ELEMENT_ERROR (trans, LIBRARY, INIT,
("Subclass failed to initialize."), (NULL));
return FALSE;
}
}
static GstFlowReturn
gst_omx_buffer_pool_alloc_buffer (GstBufferPool * bpool,
GstBuffer ** buffer, GstBufferPoolAcquireParams * params)
{
GstOMXBufferPool *pool = GST_OMX_BUFFER_POOL (bpool);
GstBuffer *buf;
GstOMXBuffer *omx_buf;
g_return_val_if_fail (pool->allocating, GST_FLOW_ERROR);
omx_buf = g_ptr_array_index (pool->port->buffers, pool->current_buffer_index);
g_return_val_if_fail (omx_buf != NULL, GST_FLOW_ERROR);
if (pool->other_pool) {
guint i, n;
buf = g_ptr_array_index (pool->buffers, pool->current_buffer_index);
g_assert (pool->other_pool == buf->pool);
gst_object_replace ((GstObject **) & buf->pool, NULL);
n = gst_buffer_n_memory (buf);
for (i = 0; i < n; i++) {
GstMemory *mem = gst_buffer_peek_memory (buf, i);
/* FIXME: We don't allow sharing because we need to know
* when the memory becomes unused and can only then put
* it back to the pool. Which is done in the pool's release
* function
*/
GST_MINI_OBJECT_FLAG_SET (mem, GST_MEMORY_FLAG_NO_SHARE);
}
if (pool->add_videometa) {
GstVideoMeta *meta;
meta = gst_buffer_get_video_meta (buf);
if (!meta) {
gst_buffer_add_video_meta (buf, GST_VIDEO_FRAME_FLAG_NONE,
GST_VIDEO_INFO_FORMAT (&pool->video_info),
GST_VIDEO_INFO_WIDTH (&pool->video_info),
GST_VIDEO_INFO_HEIGHT (&pool->video_info));
}
}
pool->need_copy = FALSE;
} else {
GstMemory *mem;
const guint nstride = pool->port->port_def.format.video.nStride;
const guint nslice = pool->port->port_def.format.video.nSliceHeight;
gsize offset[GST_VIDEO_MAX_PLANES] = { 0, };
gint stride[GST_VIDEO_MAX_PLANES] = { nstride, 0, };
mem = gst_omx_memory_allocator_alloc (pool->allocator, 0, omx_buf);
buf = gst_buffer_new ();
gst_buffer_append_memory (buf, mem);
g_ptr_array_add (pool->buffers, buf);
switch (GST_VIDEO_INFO_FORMAT (&pool->video_info)) {
case GST_VIDEO_FORMAT_ABGR:
case GST_VIDEO_FORMAT_ARGB:
case GST_VIDEO_FORMAT_RGB16:
case GST_VIDEO_FORMAT_BGR16:
case GST_VIDEO_FORMAT_YUY2:
case GST_VIDEO_FORMAT_UYVY:
case GST_VIDEO_FORMAT_YVYU:
case GST_VIDEO_FORMAT_GRAY8:
break;
case GST_VIDEO_FORMAT_I420:
stride[1] = nstride / 2;
offset[1] = offset[0] + stride[0] * nslice;
stride[2] = nstride / 2;
offset[2] = offset[1] + (stride[1] * nslice / 2);
break;
case GST_VIDEO_FORMAT_NV12:
case GST_VIDEO_FORMAT_NV16:
stride[1] = nstride;
offset[1] = offset[0] + stride[0] * nslice;
break;
default:
g_assert_not_reached ();
break;
}
if (pool->add_videometa) {
pool->need_copy = FALSE;
} else {
GstVideoInfo info;
gboolean need_copy = FALSE;
gint i;
gst_video_info_init (&info);
gst_video_info_set_format (&info,
GST_VIDEO_INFO_FORMAT (&pool->video_info),
GST_VIDEO_INFO_WIDTH (&pool->video_info),
GST_VIDEO_INFO_HEIGHT (&pool->video_info));
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (&pool->video_info); i++) {
if (info.stride[i] != stride[i] || info.offset[i] != offset[i]) {
need_copy = TRUE;
break;
}
}
pool->need_copy = need_copy;
}
if (pool->need_copy || pool->add_videometa) {
/* We always add the videometa. It's the job of the user
* to copy the buffer if pool->need_copy is TRUE
*/
gst_buffer_add_video_meta_full (buf, GST_VIDEO_FRAME_FLAG_NONE,
GST_VIDEO_INFO_FORMAT (&pool->video_info),
GST_VIDEO_INFO_WIDTH (&pool->video_info),
GST_VIDEO_INFO_HEIGHT (&pool->video_info),
GST_VIDEO_INFO_N_PLANES (&pool->video_info), offset, stride);
}
}
gst_mini_object_set_qdata (GST_MINI_OBJECT_CAST (buf),
gst_omx_buffer_data_quark, omx_buf, NULL);
*buffer = buf;
pool->current_buffer_index++;
return GST_FLOW_OK;
}
static gboolean
gst_rtp_vraw_depay_setcaps (GstRTPBaseDepayload * depayload, GstCaps * caps)
{
GstStructure *structure;
GstRtpVRawDepay *rtpvrawdepay;
gint clock_rate;
const gchar *str;
gint format, width, height, depth, pgroup, xinc, yinc;
GstCaps *srccaps;
gboolean res;
GstFlowReturn ret;
rtpvrawdepay = GST_RTP_VRAW_DEPAY (depayload);
structure = gst_caps_get_structure (caps, 0);
xinc = yinc = 1;
if (!gst_structure_get_int (structure, "clock-rate", &clock_rate))
clock_rate = 90000; /* default */
depayload->clock_rate = clock_rate;
if (!(str = gst_structure_get_string (structure, "width")))
goto no_width;
width = atoi (str);
if (!(str = gst_structure_get_string (structure, "height")))
goto no_height;
height = atoi (str);
if (!(str = gst_structure_get_string (structure, "depth")))
goto no_depth;
depth = atoi (str);
/* optional interlace value but we don't handle interlaced
* formats yet */
if (gst_structure_get_string (structure, "interlace"))
goto interlaced;
if (!(str = gst_structure_get_string (structure, "sampling")))
goto no_sampling;
if (!strcmp (str, "RGB")) {
format = GST_VIDEO_FORMAT_RGB;
pgroup = 3;
} else if (!strcmp (str, "RGBA")) {
format = GST_VIDEO_FORMAT_RGBA;
pgroup = 4;
} else if (!strcmp (str, "BGR")) {
format = GST_VIDEO_FORMAT_BGR;
pgroup = 3;
} else if (!strcmp (str, "BGRA")) {
format = GST_VIDEO_FORMAT_BGRA;
pgroup = 4;
} else if (!strcmp (str, "YCbCr-4:4:4")) {
format = GST_VIDEO_FORMAT_AYUV;
pgroup = 3;
} else if (!strcmp (str, "YCbCr-4:2:2")) {
if (depth == 8) {
format = GST_VIDEO_FORMAT_UYVY;
pgroup = 4;
} else if (depth == 10) {
format = GST_VIDEO_FORMAT_UYVP;
pgroup = 5;
} else
goto unknown_format;
xinc = 2;
} else if (!strcmp (str, "YCbCr-4:2:0")) {
format = GST_VIDEO_FORMAT_I420;
pgroup = 6;
xinc = yinc = 2;
} else if (!strcmp (str, "YCbCr-4:1:1")) {
format = GST_VIDEO_FORMAT_Y41B;
pgroup = 6;
xinc = 4;
} else {
goto unknown_format;
}
gst_video_info_init (&rtpvrawdepay->vinfo);
gst_video_info_set_format (&rtpvrawdepay->vinfo, format, width, height);
GST_VIDEO_INFO_FPS_N (&rtpvrawdepay->vinfo) = 0;
GST_VIDEO_INFO_FPS_D (&rtpvrawdepay->vinfo) = 1;
rtpvrawdepay->pgroup = pgroup;
rtpvrawdepay->xinc = xinc;
rtpvrawdepay->yinc = yinc;
srccaps = gst_video_info_to_caps (&rtpvrawdepay->vinfo);
res = gst_pad_set_caps (GST_RTP_BASE_DEPAYLOAD_SRCPAD (depayload), srccaps);
gst_caps_unref (srccaps);
GST_DEBUG_OBJECT (depayload, "width %d, height %d, format %d", width, height,
format);
GST_DEBUG_OBJECT (depayload, "xinc %d, yinc %d, pgroup %d",
xinc, yinc, pgroup);
/* negotiate a bufferpool */
if ((ret = gst_rtp_vraw_depay_negotiate_pool (rtpvrawdepay, srccaps,
&rtpvrawdepay->vinfo)) != GST_FLOW_OK)
goto no_bufferpool;
return res;
/* ERRORS */
no_width:
{
GST_ERROR_OBJECT (depayload, "no width specified");
return FALSE;
}
no_height:
{
GST_ERROR_OBJECT (depayload, "no height specified");
return FALSE;
}
no_depth:
{
GST_ERROR_OBJECT (depayload, "no depth specified");
return FALSE;
}
interlaced:
{
GST_ERROR_OBJECT (depayload, "interlaced formats not supported yet");
return FALSE;
}
no_sampling:
{
GST_ERROR_OBJECT (depayload, "no sampling specified");
return FALSE;
}
unknown_format:
{
GST_ERROR_OBJECT (depayload, "unknown sampling format '%s'", str);
return FALSE;
}
no_bufferpool:
{
GST_DEBUG_OBJECT (depayload, "no bufferpool");
return FALSE;
}
}
static gboolean
gst_validate_ssim_get_frame_from_file (GstValidateSsim * self, const char *file,
GstVideoFrame * frame)
{
gchar *data;
gsize length;
GstBuffer *buf;
GstVideoInfo info;
GstVideoFormat format;
gint strv_length, width, height;
gboolean res = TRUE;
gchar **splited_name = NULL, **splited_size = NULL, *strformat;
GError *error = NULL;
if (g_str_has_suffix (file, ".png")) {
return gst_validate_ssim_get_frame_from_png (self, file, frame);
}
splited_name = g_strsplit (file, ".", -1);
strv_length = g_strv_length (splited_name);
strformat = splited_name[strv_length - 1];
format = gst_video_format_from_string (strformat);
if (format == GST_VIDEO_FORMAT_UNKNOWN) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT, "Unknown format: %s", strformat);
goto fail;
}
splited_size = g_strsplit (splited_name[strv_length - 2], "x", -1);
if (g_strv_length (splited_size) != 2) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT,
"Can not determine video size from filename: %s ", file);
goto fail;
}
errno = 0;
width = g_ascii_strtoull (splited_size[0], NULL, 10);
if (errno) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT,
"Can not determine video size from filename: %s ", file);
goto fail;
}
errno = 0;
height = g_ascii_strtoull (splited_size[1], NULL, 10);
if (errno) {
GST_VALIDATE_REPORT (self, WRONG_FORMAT,
"Can not determine video size from filename: %s ", file);
goto fail;
}
gst_video_info_init (&info);
gst_video_info_set_format (&info, format, width, height);
if (!g_file_get_contents (file, &data, &length, &error)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR, "Could not open %s: %s",
file, error->message);
g_error_free (error);
goto fail;
}
buf = gst_buffer_new_wrapped (data, length);
if (!gst_video_frame_map (frame, &info, buf, GST_MAP_READ)) {
gst_buffer_unref (buf);
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map input frame");
goto fail;
}
gst_buffer_unref (buf);
done:
g_strfreev (splited_name);
g_strfreev (splited_size);
return res;
fail:
res = FALSE;
goto done;
}
static GstCaps *
gst_phoenixsrc_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
{
GstPhoenixSrc *src = GST_PHOENIX_SRC (bsrc);
etStat eStat = PHX_OK; /* Status variable */
etParamValue eParamValue = PHX_INVALID_PARAMVALUE;
ui32 dwParamValue = 0;
guint32 phx_format;
gint width, height;
gint bpp, depth, endianness;
GstVideoFormat videoFormat;
gboolean is_gray16 = FALSE, is_bayer = FALSE;
GstVideoInfo vinfo;
GstCaps *caps;
if (!src->hCamera) {
return gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (src));
}
/* Create video info */
gst_video_info_init (&vinfo);
/* Get format (mono, Bayer, RBG, etc.) */
eStat = PHX_ParameterGet (src->hCamera, PHX_DST_FORMAT, &dwParamValue);
if (PHX_OK != eStat)
goto ResourceSettingsError;
phx_format = dwParamValue;
/* Get endianness */
eStat = PHX_ParameterGet (src->hCamera, PHX_DST_ENDIAN, &dwParamValue);
if (PHX_OK != eStat)
goto ResourceSettingsError;
endianness =
(dwParamValue == PHX_DST_LITTLE_ENDIAN) ? G_LITTLE_ENDIAN : G_BIG_ENDIAN;
/* get width */
eStat =
PHX_ParameterGet (src->hCamera, PHX_ROI_XLENGTH_SCALED, &dwParamValue);
if (PHX_OK != eStat)
goto ResourceSettingsError;
width = dwParamValue;
/* get height */
eStat =
PHX_ParameterGet (src->hCamera, PHX_ROI_YLENGTH_SCALED, &dwParamValue);
if (PHX_OK != eStat)
goto ResourceSettingsError;
height = dwParamValue;
switch (phx_format) {
case PHX_DST_FORMAT_Y8:
videoFormat = GST_VIDEO_FORMAT_GRAY8;
break;
case PHX_DST_FORMAT_Y10:
bpp = 10;
is_gray16 = TRUE;
break;
case PHX_DST_FORMAT_Y12:
bpp = 12;
is_gray16 = TRUE;
break;
case PHX_DST_FORMAT_Y14:
bpp = 14;
is_gray16 = TRUE;
break;
case PHX_DST_FORMAT_Y16:
bpp = 16;
is_gray16 = TRUE;
break;
case PHX_DST_FORMAT_BAY8:
bpp = 8;
depth = 8;
is_bayer = TRUE;
break;
case PHX_DST_FORMAT_BAY10:
bpp = 10;
depth = 16;
is_bayer = TRUE;
break;
case PHX_DST_FORMAT_BAY12:
bpp = 12;
depth = 16;
is_bayer = TRUE;
break;
case PHX_DST_FORMAT_BAY14:
bpp = 14;
depth = 16;
is_bayer = TRUE;
break;
case PHX_DST_FORMAT_BAY16:
bpp = 16;
depth = 16;
is_bayer = TRUE;
break;
case PHX_DST_FORMAT_RGB15:
videoFormat = GST_VIDEO_FORMAT_RGB15;
break;
case PHX_DST_FORMAT_RGB16:
videoFormat = GST_VIDEO_FORMAT_RGB16;
break;
case PHX_DST_FORMAT_RGB24:
videoFormat = GST_VIDEO_FORMAT_RGB;
break;
case PHX_DST_FORMAT_RGB32: /* FIXME: what is the format of this? */
case PHX_DST_FORMAT_XRGB32:
videoFormat = GST_VIDEO_FORMAT_xRGB;
break;
default:
videoFormat = GST_VIDEO_FORMAT_UNKNOWN;
}
if (is_gray16)
videoFormat = (endianness == G_LITTLE_ENDIAN) ?
GST_VIDEO_FORMAT_GRAY16_LE : GST_VIDEO_FORMAT_GRAY16_BE;
if (is_bayer) {
const gchar *bay_fmt;
eStat = PHX_ParameterGet (src->hCamera, PHX_CAM_SRC_COL, &dwParamValue);
if (PHX_OK != eStat)
goto ResourceSettingsError;
switch (dwParamValue) {
case PHX_CAM_SRC_BAY_RGGB:
bay_fmt = (depth == 16) ? "rggb16" : "rggb";
break;
case PHX_CAM_SRC_BAY_GRBG:
bay_fmt = (depth == 16) ? "grbg16" : "grbg";
break;
case PHX_CAM_SRC_BAY_GBRG:
bay_fmt = (depth == 16) ? "gbrg16" : "gbrg";
break;
case PHX_CAM_SRC_BAY_BGGR:
bay_fmt = (depth == 16) ? "bggr16" : "bggr";
break;
default:
GST_ERROR_OBJECT (src, "Unknown PHX_CAM_SRC_COL=%d", dwParamValue);
goto Error;
}
if (depth == 8) {
caps = gst_caps_new_simple ("video/x-bayer",
"format", G_TYPE_STRING, bay_fmt,
"width", G_TYPE_INT, width,
"height", G_TYPE_INT, height,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
} else if (depth == 16) {
caps = gst_caps_new_simple ("video/x-bayer",
"format", G_TYPE_STRING, bay_fmt,
"bpp", G_TYPE_INT, bpp,
"endianness", G_TYPE_INT, endianness,
"width", G_TYPE_INT, width,
"height", G_TYPE_INT, height,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
}
} else if (videoFormat != GST_VIDEO_FORMAT_UNKNOWN) {
vinfo.finfo = gst_video_format_get_info (videoFormat);
vinfo.width = width;
vinfo.height = height;
caps = gst_video_info_to_caps (&vinfo);
if (is_gray16) {
GValue val = G_VALUE_INIT;
GstStructure *s = gst_caps_get_structure (caps, 0);
g_value_init (&val, G_TYPE_INT);
g_value_set_int (&val, bpp);
gst_structure_set_value (s, "bpp", &val);
g_value_unset (&val);
}
} else {
GST_ELEMENT_ERROR (src, STREAM, WRONG_TYPE,
(("Unknown or unsupported color format.")), (NULL));
goto Error;
}
/* get buffer size; width (in bytes) and height (in lines) */
eStat = PHX_ParameterGet (src->hCamera, PHX_BUF_DST_XLENGTH, &dwParamValue);
if (PHX_OK != eStat)
goto ResourceSettingsError;
src->phx_stride = dwParamValue;
eStat = PHX_ParameterGet (src->hCamera, PHX_BUF_DST_YLENGTH, &dwParamValue);
if (PHX_OK != eStat)
goto ResourceSettingsError;
/* TODO: should we be using PHX_BUF_DST_YLENGTH or PHX_ROI_YLENGTH_SCALED
for height? */
g_assert (dwParamValue == height);
GST_DEBUG_OBJECT (src, "The caps before filtering are %" GST_PTR_FORMAT,
caps);
if (filter) {
GstCaps *tmp = gst_caps_intersect (caps, filter);
gst_caps_unref (caps);
caps = tmp;
}
GST_DEBUG_OBJECT (src, "The caps after filtering are %" GST_PTR_FORMAT, caps);
return caps;
ResourceSettingsError:
GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS,
(("Failed to get Phoenix parameters.")), (NULL));
Error:
return NULL;
}
/* Test Callbacks and vmethods*/
static GstPipeline *
create_pipeline (InsanityGstPipelineTest * ptest, gpointer unused_data)
{
GstCaps *caps;
gulong probe_id;
GError *err = NULL;
GstIterator *it = NULL;
gchar *uri = NULL, *sublocation = NULL;
GstElement *capsfilter = NULL, *capsfilter1 = NULL, *colorspace =
NULL, *colorspace1 = NULL, *fakesink = NULL;
GstPad *fakesinksink = NULL, *tmppad = NULL;
InsanityTest *test = INSANITY_TEST (ptest);
SUBTITLES_TEST_LOCK ();
glob_pipeline = GST_ELEMENT (gst_pipeline_new ("pipeline"));
/* Create the source */
insanity_test_get_boolean_argument (test, "push-mode",
(gboolean *) & glob_push_mode);
insanity_test_get_string_argument (test, "sublocation", &sublocation);
if (sublocation == NULL || g_strcmp0 (sublocation, "") == 0) {
ERROR (test, "Location name not set\n");
goto creation_failed;
}
uri = gst_filename_to_uri (sublocation, &err);
if (err != NULL) {
ERROR (test, "Error creating uri %s", err->message);
goto creation_failed;
}
if (glob_push_mode == TRUE) {
gchar *tmpuri;
glob_uridecodebin = gst_element_factory_make ("pushfilesrc", "src");
tmpuri = g_strconcat ("push", uri, NULL);
g_free (uri);
uri = tmpuri;
}
glob_uridecodebin = gst_element_factory_make ("uridecodebin", "src");
g_signal_connect (glob_uridecodebin, "pad-added", G_CALLBACK (pad_added_cb),
test);
g_object_set (glob_uridecodebin, "uri", uri, NULL);
/* the subtitleoverlay */
glob_suboverlay =
gst_element_factory_make ("subtitleoverlay", "subtitleoverlay");
if (glob_suboverlay == NULL)
goto creation_failed;
/* the fakesink */
fakesink = gst_element_factory_make ("fakesink", "fakesink");
if (fakesink == NULL)
goto creation_failed;
/* and the videotestsrc */
glob_videotestsrc = gst_element_factory_make ("videotestsrc", "videotestsrc");
if (glob_videotestsrc == NULL)
goto creation_failed;
g_object_set (glob_videotestsrc, "pattern", 2, "do-timestamp", TRUE, NULL);
/* Make sure the video is big enough */
capsfilter = gst_element_factory_make ("capsfilter", NULL);
if (capsfilter == NULL)
goto creation_failed;
gst_video_info_init (&glob_video_info);
gst_video_info_set_format (&glob_video_info, GST_VIDEO_FORMAT_RGB, 1920,
1080);
caps = gst_video_info_to_caps (&glob_video_info);
g_object_set (capsfilter, "caps", caps, NULL);
capsfilter1 = gst_element_factory_make ("capsfilter", NULL);
if (capsfilter1 == NULL)
goto creation_failed;
/* We want the last frame that we will "parse" to check if it contains
* subtitles to be in RGB to make simpler for us */
g_object_set (capsfilter1, "caps", caps, NULL);
colorspace = gst_element_factory_make ("videoconvert", NULL);
if (colorspace == NULL)
goto creation_failed;
colorspace1 = gst_element_factory_make ("videoconvert", NULL);
if (colorspace1 == NULL)
goto creation_failed;
/* Now add to the pipeline */
gst_bin_add_many (GST_BIN (glob_pipeline), glob_uridecodebin,
glob_videotestsrc, capsfilter, glob_suboverlay,
capsfilter1, colorspace, colorspace1, fakesink, NULL);
/* link video branch elements */
gst_element_link_many (glob_videotestsrc, capsfilter,
glob_suboverlay, colorspace, capsfilter1, fakesink, NULL);
/* And install a probe to the subtitleoverlay src pad */
fakesinksink = gst_element_get_static_pad (fakesink, "sink");
if (fakesinksink == NULL)
goto failed;
if (insanity_gst_test_add_data_probe (INSANITY_GST_TEST (test),
GST_BIN (glob_pipeline), GST_OBJECT_NAME (fakesink),
GST_OBJECT_NAME (fakesinksink), &tmppad, &probe_id,
&probe_cb, NULL, NULL) == TRUE) {
glob_suboverlay_src_probe = g_slice_new0 (ProbeContext);
glob_suboverlay_src_probe->probe_id = probe_id;
glob_suboverlay_src_probe->pad = fakesinksink;
glob_suboverlay_src_probe->element = fakesink;
glob_suboverlay_src_probe->test = test;
glob_suboverlay_src_probe->waiting_first_segment = TRUE;
insanity_test_validate_checklist_item (test, "install-probes", TRUE, NULL);
} else {
insanity_test_validate_checklist_item (test,
"install-probes", FALSE, "Failed to attach probe to fakesink");
insanity_test_done (test);
goto failed;
}
g_signal_connect (GST_CHILD_PROXY (glob_suboverlay), "child-added",
G_CALLBACK (suboverlay_child_added_cb), test);
done:
SUBTITLES_TEST_UNLOCK ();
g_free (uri);
g_free (sublocation);
if (err != NULL)
g_error_free (err);
if (it != NULL)
gst_iterator_free (it);
return GST_PIPELINE (glob_pipeline);
failed:
if (glob_pipeline != NULL)
gst_object_unref (glob_pipeline);
glob_suboverlay = glob_pipeline = glob_videotestsrc =
glob_uridecodebin = NULL;
goto done;
creation_failed:
if (glob_uridecodebin != NULL)
gst_object_unref (glob_uridecodebin);
if (glob_suboverlay != NULL)
gst_object_unref (glob_suboverlay);
if (glob_videotestsrc != NULL)
gst_object_unref (glob_videotestsrc);
if (fakesink != NULL)
gst_object_unref (fakesink);
goto failed;
}
static void
gst_validate_ssim_save_out (GstValidateSsim * self, GstBuffer * buffer,
const gchar * ref_file, const gchar * file, const gchar * outfolder)
{
GstVideoFrame frame, converted;
if (!g_file_test (outfolder, G_FILE_TEST_IS_DIR)) {
if (g_mkdir_with_parents (outfolder, 0755) != 0) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not create output directory %s", outfolder);
return;
}
}
if (self->priv->outconverter_info.converter == NULL ||
self->priv->width != self->priv->outconverter_info.out_info.width ||
self->priv->height != self->priv->outconverter_info.out_info.height) {
if (self->priv->outconverter_info.converter)
gst_video_converter_free (self->priv->outconverter_info.converter);
gst_video_info_init (&self->priv->outconverter_info.in_info);
gst_video_info_set_format (&self->priv->outconverter_info.in_info,
GST_VIDEO_FORMAT_GRAY8, self->priv->width, self->priv->height);
gst_video_info_init (&self->priv->outconverter_info.out_info);
gst_video_info_set_format (&self->priv->outconverter_info.out_info,
GST_VIDEO_FORMAT_RGBx, self->priv->width, self->priv->height);
self->priv->outconverter_info.converter =
gst_video_converter_new (&self->priv->outconverter_info.in_info,
&self->priv->outconverter_info.out_info, NULL);
}
if (!gst_video_frame_map (&frame, &self->priv->outconverter_info.in_info,
buffer, GST_MAP_READ)) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not map output frame");
return;
}
if (gst_validate_ssim_convert (self, &self->priv->outconverter_info,
&frame, &converted)) {
cairo_status_t status;
cairo_surface_t *surface;
gchar *bn1 = g_path_get_basename (ref_file);
gchar *bn2 = g_path_get_basename (file);
gchar *fname = g_strdup_printf ("%s.VS.%s.result.png", bn1, bn2);
gchar *outfile = g_build_path (G_DIR_SEPARATOR_S, outfolder, fname, NULL);
surface =
cairo_image_surface_create_for_data (GST_VIDEO_FRAME_PLANE_DATA
(&converted, 0), CAIRO_FORMAT_RGB24, GST_VIDEO_FRAME_WIDTH (&converted),
GST_VIDEO_FRAME_HEIGHT (&converted),
GST_VIDEO_FRAME_PLANE_STRIDE (&converted, 0));
if ((status = cairo_surface_write_to_png (surface, outfile)) !=
CAIRO_STATUS_SUCCESS) {
GST_VALIDATE_REPORT (self, GENERAL_INPUT_ERROR,
"Could not save '%s', cairo status is '%s'", outfile,
cairo_status_to_string (status));
}
cairo_surface_destroy (surface);
gst_video_frame_unmap (&frame);
gst_video_frame_unmap (&converted);
g_free (bn1);
g_free (bn2);
g_free (fname);
g_free (outfile);
}
}
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;
}
/**
* gst_vaapi_plugin_base_decide_allocation:
* @plugin: a #GstVaapiPluginBase
* @query: the allocation query to parse
* @feature: the desired #GstVaapiCapsFeature, or zero to find the
* preferred one
*
* Decides allocation parameters for the downstream elements.
*
* Returns: %TRUE if successful, %FALSE otherwise.
*/
gboolean
gst_vaapi_plugin_base_decide_allocation (GstVaapiPluginBase * plugin,
GstQuery * query, guint feature)
{
GstCaps *caps = NULL;
GstBufferPool *pool;
GstStructure *config;
GstVideoInfo vi;
guint size, min, max;
gboolean update_pool = FALSE;
gboolean has_video_meta = FALSE;
gboolean has_video_alignment = FALSE;
#if (USE_GLX || USE_EGL)
gboolean has_texture_upload_meta = FALSE;
guint idx;
#endif
g_return_val_if_fail (plugin->display != NULL, FALSE);
gst_query_parse_allocation (query, &caps, NULL);
/* We don't need any GL context beyond this point if not requested
so explicitly through GstVideoGLTextureUploadMeta */
gst_object_replace (&plugin->gl_context, NULL);
if (!caps)
goto error_no_caps;
if (!feature)
feature =
gst_vaapi_find_preferred_caps_feature (plugin->srcpad,
GST_VIDEO_FORMAT_ENCODED, NULL);
has_video_meta = gst_query_find_allocation_meta (query,
GST_VIDEO_META_API_TYPE, NULL);
#if (USE_GLX || USE_EGL)
has_texture_upload_meta = gst_query_find_allocation_meta (query,
GST_VIDEO_GL_TEXTURE_UPLOAD_META_API_TYPE, &idx) &&
(feature == GST_VAAPI_CAPS_FEATURE_GL_TEXTURE_UPLOAD_META);
#if USE_GST_GL_HELPERS
if (has_texture_upload_meta) {
const GstStructure *params;
GstObject *gl_context;
gst_query_parse_nth_allocation_meta (query, idx, ¶ms);
if (params) {
if (gst_structure_get (params, "gst.gl.GstGLContext", GST_GL_TYPE_CONTEXT,
&gl_context, NULL) && gl_context) {
gst_vaapi_plugin_base_set_gl_context (plugin, gl_context);
gst_object_unref (gl_context);
}
}
}
#endif
#endif
/* Make sure the display we pass down to the buffer pool is actually
the expected one, especially when the downstream element requires
a GLX or EGL display */
if (!gst_vaapi_plugin_base_ensure_display (plugin))
goto error_ensure_display;
gst_video_info_init (&vi);
gst_video_info_from_caps (&vi, caps);
if (GST_VIDEO_INFO_FORMAT (&vi) == GST_VIDEO_FORMAT_ENCODED)
gst_video_info_set_format (&vi, GST_VIDEO_FORMAT_I420,
GST_VIDEO_INFO_WIDTH (&vi), GST_VIDEO_INFO_HEIGHT (&vi));
if (gst_query_get_n_allocation_pools (query) > 0) {
gst_query_parse_nth_allocation_pool (query, 0, &pool, &size, &min, &max);
update_pool = TRUE;
size = MAX (size, vi.size);
if (pool) {
/* Check whether downstream element proposed a bufferpool but did
not provide a correct propose_allocation() implementation */
has_video_alignment = gst_buffer_pool_has_option (pool,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT);
}
} else {
pool = NULL;
size = vi.size;
min = max = 0;
}
/* GstVaapiVideoMeta is mandatory, and this implies VA surface memory */
if (!pool || !gst_buffer_pool_has_option (pool,
GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META)) {
GST_INFO_OBJECT (plugin, "%s. Making a new pool", pool == NULL ? "No pool" :
"Pool hasn't GstVaapiVideoMeta");
if (pool)
gst_object_unref (pool);
pool = gst_vaapi_video_buffer_pool_new (plugin->display);
if (!pool)
goto error_create_pool;
config = gst_buffer_pool_get_config (pool);
gst_buffer_pool_config_set_params (config, caps, size, min, max);
gst_buffer_pool_config_add_option (config,
GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META);
if (!gst_buffer_pool_set_config (pool, config))
goto config_failed;
}
/* Check whether GstVideoMeta, or GstVideoAlignment, is needed (raw video) */
if (has_video_meta) {
if (!gst_vaapi_plugin_base_set_pool_config (pool,
GST_BUFFER_POOL_OPTION_VIDEO_META))
goto config_failed;
} else if (has_video_alignment) {
if (!gst_vaapi_plugin_base_set_pool_config (pool,
GST_BUFFER_POOL_OPTION_VIDEO_ALIGNMENT))
goto config_failed;
}
/* GstVideoGLTextureUploadMeta (OpenGL) */
#if (USE_GLX || USE_EGL)
if (has_texture_upload_meta) {
if (!gst_vaapi_plugin_base_set_pool_config (pool,
GST_BUFFER_POOL_OPTION_VIDEO_GL_TEXTURE_UPLOAD_META))
goto config_failed;
}
#endif
if (update_pool)
gst_query_set_nth_allocation_pool (query, 0, pool, size, min, max);
else
gst_query_add_allocation_pool (query, pool, size, min, max);
g_clear_object (&plugin->srcpad_buffer_pool);
plugin->srcpad_buffer_pool = pool;
return TRUE;
/* ERRORS */
error_no_caps:
{
GST_ERROR_OBJECT (plugin, "no caps specified");
return FALSE;
}
error_ensure_display:
{
GST_ERROR_OBJECT (plugin, "failed to ensure display of type %d",
plugin->display_type_req);
return FALSE;
}
error_create_pool:
{
GST_ERROR_OBJECT (plugin, "failed to create buffer pool");
return FALSE;
}
config_failed:
{
if (pool)
gst_object_unref (pool);
GST_ELEMENT_ERROR (plugin, RESOURCE, SETTINGS,
("Failed to configure the buffer pool"),
("Configuration is most likely invalid, please report this issue."));
return FALSE;
}
}
static gboolean
gst_rfb_src_negotiate (GstBaseSrc * bsrc)
{
GstRfbSrc *src = GST_RFB_SRC (bsrc);
RfbDecoder *decoder;
GstCaps *caps;
GstVideoInfo vinfo;
GstVideoFormat vformat;
guint32 red_mask, green_mask, blue_mask;
gchar *stream_id = NULL;
GstEvent *stream_start = NULL;
decoder = src->decoder;
if (decoder->inited)
return TRUE;
GST_DEBUG_OBJECT (src, "connecting to host %s on port %d",
src->host, src->port);
if (!rfb_decoder_connect_tcp (decoder, src->host, src->port)) {
if (decoder->error != NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, READ,
("Could not connect to VNC server %s on port %d: %s", src->host,
src->port, decoder->error->message), (NULL));
} else {
GST_ELEMENT_ERROR (src, RESOURCE, READ,
("Could not connect to VNC server %s on port %d", src->host,
src->port), (NULL));
}
return FALSE;
}
while (!decoder->inited) {
if (!rfb_decoder_iterate (decoder)) {
if (decoder->error != NULL) {
GST_ELEMENT_ERROR (src, RESOURCE, READ,
("Failed to setup VNC connection to host %s on port %d: %s",
src->host, src->port, decoder->error->message), (NULL));
} else {
GST_ELEMENT_ERROR (src, RESOURCE, READ,
("Failed to setup VNC connection to host %s on port %d", src->host,
src->port), (NULL));
}
return FALSE;
}
}
stream_id = gst_pad_create_stream_id_printf (GST_BASE_SRC_PAD (bsrc),
GST_ELEMENT (src), "%s:%d", src->host, src->port);
stream_start = gst_event_new_stream_start (stream_id);
g_free (stream_id);
gst_pad_push_event (GST_BASE_SRC_PAD (bsrc), stream_start);
decoder->rect_width =
(decoder->rect_width ? decoder->rect_width : decoder->width);
decoder->rect_height =
(decoder->rect_height ? decoder->rect_height : decoder->height);
decoder->decoder_private = src;
/* calculate some many used values */
decoder->bytespp = decoder->bpp / 8;
decoder->line_size = decoder->rect_width * decoder->bytespp;
GST_DEBUG_OBJECT (src, "setting caps width to %d and height to %d",
decoder->rect_width, decoder->rect_height);
red_mask = decoder->red_max << decoder->red_shift;
green_mask = decoder->green_max << decoder->green_shift;
blue_mask = decoder->blue_max << decoder->blue_shift;
vformat = gst_video_format_from_masks (decoder->depth, decoder->bpp,
decoder->big_endian ? G_BIG_ENDIAN : G_LITTLE_ENDIAN,
red_mask, green_mask, blue_mask, 0);
gst_video_info_init (&vinfo);
gst_video_info_set_format (&vinfo, vformat, decoder->rect_width,
decoder->rect_height);
decoder->frame = g_malloc (vinfo.size);
if (decoder->use_copyrect)
decoder->prev_frame = g_malloc (vinfo.size);
caps = gst_video_info_to_caps (&vinfo);
gst_base_src_set_caps (bsrc, caps);
gst_caps_unref (caps);
return TRUE;
}
/**
* gst_video_info_from_caps:
* @info: a #GstVideoInfo
* @caps: a #GstCaps
*
* Parse @caps and update @info.
*
* Returns: TRUE if @caps could be parsed
*/
gboolean
gst_video_info_from_caps (GstVideoInfo * info, const GstCaps * caps)
{
GstStructure *structure;
const gchar *s;
GstVideoFormat format = GST_VIDEO_FORMAT_UNKNOWN;
gint width = 0, height = 0;
gint fps_n, fps_d;
gint par_n, par_d;
g_return_val_if_fail (info != NULL, FALSE);
g_return_val_if_fail (caps != NULL, FALSE);
g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE);
GST_DEBUG ("parsing caps %" GST_PTR_FORMAT, caps);
structure = gst_caps_get_structure (caps, 0);
if (gst_structure_has_name (structure, "video/x-raw")) {
if (!(s = gst_structure_get_string (structure, "format")))
goto no_format;
format = gst_video_format_from_string (s);
if (format == GST_VIDEO_FORMAT_UNKNOWN)
goto unknown_format;
} else if (g_str_has_prefix (gst_structure_get_name (structure), "video/") ||
g_str_has_prefix (gst_structure_get_name (structure), "image/")) {
format = GST_VIDEO_FORMAT_ENCODED;
} else {
goto wrong_name;
}
/* width and height are mandatory, except for non-raw-formats */
if (!gst_structure_get_int (structure, "width", &width) &&
format != GST_VIDEO_FORMAT_ENCODED)
goto no_width;
if (!gst_structure_get_int (structure, "height", &height) &&
format != GST_VIDEO_FORMAT_ENCODED)
goto no_height;
gst_video_info_init (info);
info->finfo = gst_video_format_get_info (format);
info->width = width;
info->height = height;
if (gst_structure_get_fraction (structure, "framerate", &fps_n, &fps_d)) {
if (fps_n == 0) {
/* variable framerate */
info->flags |= GST_VIDEO_FLAG_VARIABLE_FPS;
/* see if we have a max-framerate */
gst_structure_get_fraction (structure, "max-framerate", &fps_n, &fps_d);
}
info->fps_n = fps_n;
info->fps_d = fps_d;
} else {
/* unspecified is variable framerate */
info->fps_n = 0;
info->fps_d = 1;
}
if (gst_structure_get_fraction (structure, "pixel-aspect-ratio",
&par_n, &par_d)) {
info->par_n = par_n;
info->par_d = par_d;
} else {
info->par_n = 1;
info->par_d = 1;
}
if ((s = gst_structure_get_string (structure, "interlace-mode")))
info->interlace_mode = gst_video_interlace_mode_from_string (s);
else
info->interlace_mode = GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
{
if ((s = gst_structure_get_string (structure, "multiview-mode")))
GST_VIDEO_INFO_MULTIVIEW_MODE (info) =
gst_video_multiview_mode_from_caps_string (s);
else
GST_VIDEO_INFO_MULTIVIEW_MODE (info) = GST_VIDEO_MULTIVIEW_MODE_NONE;
gst_structure_get_flagset (structure, "multiview-flags",
&GST_VIDEO_INFO_MULTIVIEW_FLAGS (info), NULL);
if (!gst_structure_get_int (structure, "views", &info->views))
info->views = 1;
/* At one point, I tried normalising the half-aspect flag here,
* but it behaves weird for GstVideoInfo operations other than
* directly converting to/from caps - sometimes causing the
* PAR to be doubled/halved too many times */
}
if ((s = gst_structure_get_string (structure, "chroma-site")))
info->chroma_site = gst_video_chroma_from_string (s);
else
info->chroma_site = GST_VIDEO_CHROMA_SITE_UNKNOWN;
if ((s = gst_structure_get_string (structure, "colorimetry"))) {
if (!gst_video_colorimetry_from_string (&info->colorimetry, s)) {
GST_WARNING ("unparsable colorimetry, using default");
set_default_colorimetry (info);
} else if (!validate_colorimetry (info)) {
GST_WARNING ("invalid colorimetry, using default");
set_default_colorimetry (info);
} else {
/* force RGB matrix for RGB formats */
if (GST_VIDEO_FORMAT_INFO_IS_RGB (info->finfo) &&
info->colorimetry.matrix != GST_VIDEO_COLOR_MATRIX_RGB) {
GST_WARNING ("invalid matrix %d for RGB format, using RGB",
info->colorimetry.matrix);
info->colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_RGB;
}
}
} else {
GST_DEBUG ("no colorimetry, using default");
set_default_colorimetry (info);
}
fill_planes (info);
return TRUE;
/* ERROR */
wrong_name:
{
GST_ERROR ("wrong name '%s', expected video/ or image/",
gst_structure_get_name (structure));
return FALSE;
}
no_format:
{
GST_ERROR ("no format given");
return FALSE;
}
unknown_format:
{
GST_ERROR ("unknown format '%s' given", s);
return FALSE;
}
no_width:
{
GST_ERROR ("no width property given");
return FALSE;
}
no_height:
{
GST_ERROR ("no height property given");
return FALSE;
}
}
static gboolean
gst_video_test_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps)
{
const GstStructure *structure;
GstVideoTestSrc *videotestsrc;
GstVideoInfo info;
videotestsrc = GST_VIDEO_TEST_SRC (bsrc);
structure = gst_caps_get_structure (caps, 0);
if (gst_structure_has_name (structure, "video/x-raw")) {
/* we can use the parsing code */
if (!gst_video_info_from_caps (&info, caps))
goto parse_failed;
} else if (gst_structure_has_name (structure, "video/x-bayer")) {
gint x_inv = 0, y_inv = 0;
gst_video_info_init (&info);
info.finfo = gst_video_format_get_info (GST_VIDEO_FORMAT_GRAY8);
if (!gst_video_test_src_parse_caps (caps, &info.width, &info.height,
&info.fps_n, &info.fps_d, &info.colorimetry, &x_inv, &y_inv))
goto parse_failed;
info.size = GST_ROUND_UP_4 (info.width) * info.height;
info.stride[0] = GST_ROUND_UP_4 (info.width);
videotestsrc->bayer = TRUE;
videotestsrc->x_invert = x_inv;
videotestsrc->y_invert = y_inv;
}
/* looks ok here */
videotestsrc->info = info;
GST_DEBUG_OBJECT (videotestsrc, "size %dx%d, %d/%d fps",
info.width, info.height, info.fps_n, info.fps_d);
g_free (videotestsrc->tmpline);
g_free (videotestsrc->tmpline2);
g_free (videotestsrc->tmpline_u8);
g_free (videotestsrc->tmpline_u16);
videotestsrc->tmpline_u8 = g_malloc (info.width + 8);
videotestsrc->tmpline = g_malloc ((info.width + 8) * 4);
videotestsrc->tmpline2 = g_malloc ((info.width + 8) * 4);
videotestsrc->tmpline_u16 = g_malloc ((info.width + 16) * 8);
videotestsrc->accum_rtime += videotestsrc->running_time;
videotestsrc->accum_frames += videotestsrc->n_frames;
videotestsrc->running_time = 0;
videotestsrc->n_frames = 0;
return TRUE;
/* ERRORS */
parse_failed:
{
GST_DEBUG_OBJECT (bsrc, "failed to parse caps");
return FALSE;
}
}
