GstMemory * gst_droid_media_buffer_allocator_alloc_from_data (GstAllocator * allocator, GstVideoInfo * info, DroidMediaData * data, DroidMediaBufferCallbacks * cb) { GstDroidMediaBufferMemory *mem; DroidMediaBuffer *buffer; int format; GstDroidMediaBufferAllocator *alloc; if (!GST_IS_DROID_MEDIA_BUFFER_ALLOCATOR (allocator)) { GST_WARNING_OBJECT (allocator, "allocator is not the correct allocator for droidmediabuffer"); return NULL; } alloc = (GstDroidMediaBufferAllocator *) allocator; if (info->finfo->format == GST_VIDEO_FORMAT_YV12) { format = alloc->c.HAL_PIXEL_FORMAT_YV12; } else if (info->finfo->format == GST_VIDEO_FORMAT_NV21) { format = alloc->c.HAL_PIXEL_FORMAT_YCrCb_420_SP; } else { GST_WARNING_OBJECT (allocator, "Unknown GStreamer format %s", gst_video_format_to_string (info->finfo->format)); return NULL; } mem = g_slice_new0 (GstDroidMediaBufferMemory); buffer = droid_media_buffer_create_from_raw_data (info->width, info->height, GST_VIDEO_INFO_COMP_STRIDE (info, 0), GST_VIDEO_INFO_COMP_STRIDE (info, 1), format, data, cb); if (!buffer) { GST_ERROR_OBJECT (allocator, "failed to acquire media buffer"); g_slice_free (GstDroidMediaBufferMemory, mem); return NULL; } mem->buffer = buffer; gst_memory_init (GST_MEMORY_CAST (mem), GST_MEMORY_FLAG_NO_SHARE | GST_MEMORY_FLAG_NOT_MAPPABLE, allocator, NULL, 0, 0, 0, 0); GST_DEBUG_OBJECT (allocator, "alloc %p", mem); return GST_MEMORY_CAST (mem); }
static gboolean gst_phoenixsrc_set_caps (GstBaseSrc * bsrc, GstCaps * caps) { GstPhoenixSrc *src = GST_PHOENIX_SRC (bsrc); GstVideoInfo vinfo; GstStructure *s = gst_caps_get_structure (caps, 0); GST_DEBUG_OBJECT (src, "The caps being set are %" GST_PTR_FORMAT, caps); gst_video_info_from_caps (&vinfo, caps); if (g_str_equal ("video/x-bayer", gst_structure_get_name (s))) { gint width; const gchar *format; gst_structure_get_int (s, "width", &width); gst_structure_get_int (s, "height", &src->height); format = gst_structure_get_string (s, "format"); if (g_str_has_suffix (format, "16")) src->gst_stride = GST_ROUND_UP_4 (width * 2); else src->gst_stride = GST_ROUND_UP_4 (width); } else if (GST_VIDEO_INFO_FORMAT (&vinfo) != GST_VIDEO_FORMAT_UNKNOWN) { src->gst_stride = GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0); src->height = vinfo.height; } else { goto unsupported_caps; } return TRUE; unsupported_caps: GST_ERROR_OBJECT (src, "Unsupported caps: %" GST_PTR_FORMAT, caps); return FALSE; }
gboolean gst_niimaqsrc_set_caps (GstBaseSrc * bsrc, GstCaps * caps) { GstNiImaqSrc *src = GST_NIIMAQSRC (bsrc); gboolean res = TRUE; int depth, ncomps; GstVideoInfo vinfo; res = gst_video_info_from_caps (&vinfo, caps); if (!res) { GST_WARNING_OBJECT (src, "Unable to parse video info from caps"); return res; } src->format = GST_VIDEO_INFO_FORMAT (&vinfo); src->width = GST_VIDEO_INFO_WIDTH (&vinfo); src->height = GST_VIDEO_INFO_HEIGHT (&vinfo); /* this will handle byte alignment (i.e. row multiple of 4 bytes) */ src->framesize = GST_VIDEO_INFO_SIZE (&vinfo); gst_base_src_set_blocksize (bsrc, src->framesize); ncomps = GST_VIDEO_INFO_N_COMPONENTS (&vinfo); depth = GST_VIDEO_INFO_COMP_DEPTH (&vinfo, 0); /* use this so NI can give us proper byte alignment */ src->rowpixels = GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0) / (ncomps * depth / 8); GST_LOG_OBJECT (src, "Caps set, framesize=%d, rowpixels=%d", src->framesize, src->rowpixels); return res; }
GstMemory * gst_droid_media_buffer_allocator_alloc_from_data (GstAllocator * allocator, GstVideoInfo * info, DroidMediaData * data, DroidMediaBufferCallbacks * cb) { GstDroidMediaBufferMemory *mem; DroidMediaBuffer *buffer; DroidMediaBufferInfo droid_info; int format_index; if (!GST_IS_DROID_MEDIA_BUFFER_ALLOCATOR (allocator)) { GST_WARNING_OBJECT (allocator, "allocator is not the correct allocator for droidmediabuffer"); return NULL; } format_index = gst_droid_media_buffer_index_of_gst_format (info->finfo->format); if (format_index == GST_DROID_MEDIA_BUFFER_FORMAT_COUNT) { GST_WARNING_OBJECT (allocator, "Unknown GStreamer format %s", gst_video_format_to_string (info->finfo->format)); return NULL; } buffer = droid_media_buffer_create_from_raw_data (info->width, info->height, GST_VIDEO_INFO_COMP_STRIDE (info, 0), GST_VIDEO_INFO_COMP_STRIDE (info, 1), gst_droid_media_buffer_formats[format_index].hal_format, data, cb); if (!buffer) { GST_ERROR_OBJECT (allocator, "failed to acquire media buffer"); return NULL; } droid_media_buffer_get_info (buffer, &droid_info); mem = gst_droid_media_buffer_allocator_alloc_from_buffer (allocator, buffer, format_index, info->width, info->height, droid_info.stride); GST_DEBUG_OBJECT (allocator, "alloc %p", mem); return GST_MEMORY_CAST (mem); }
void yadif_filter (GstYadif * yadif, int parity, int tff) { int y, i; const GstVideoInfo *vi = &yadif->video_info; const GstVideoFormatInfo *vfi = vi->finfo; for (i = 0; i < GST_VIDEO_FORMAT_INFO_N_COMPONENTS (vfi); i++) { int w = GST_VIDEO_FORMAT_INFO_SCALE_WIDTH (vfi, i, vi->width); int h = GST_VIDEO_FORMAT_INFO_SCALE_HEIGHT (vfi, i, vi->height); int refs = GST_VIDEO_INFO_COMP_STRIDE (vi, i); int df = GST_VIDEO_INFO_COMP_PSTRIDE (vi, i); guint8 *prev_data = GST_VIDEO_FRAME_COMP_DATA (&yadif->prev_frame, i); guint8 *cur_data = GST_VIDEO_FRAME_COMP_DATA (&yadif->cur_frame, i); guint8 *next_data = GST_VIDEO_FRAME_COMP_DATA (&yadif->next_frame, i); guint8 *dest_data = GST_VIDEO_FRAME_COMP_DATA (&yadif->dest_frame, i); for (y = 0; y < h; y++) { if ((y ^ parity) & 1) { guint8 *prev = prev_data + y * refs; guint8 *cur = cur_data + y * refs; guint8 *next = next_data + y * refs; guint8 *dst = dest_data + y * refs; int mode = ((y == 1) || (y + 2 == h)) ? 2 : yadif->mode; #if HAVE_CPU_X86_64 if (0) { filter_line_c (dst, prev, cur, next, w, y + 1 < h ? refs : -refs, y ? -refs : refs, parity ^ tff, mode); } else { filter_line_x86_64 (dst, prev, cur, next, w, y + 1 < h ? refs : -refs, y ? -refs : refs, parity ^ tff, mode); } #else filter_line_c (dst, prev, cur, next, w, y + 1 < h ? refs : -refs, y ? -refs : refs, parity ^ tff, mode); #endif } else { guint8 *dst = dest_data + y * refs; guint8 *cur = cur_data + y * refs; memcpy (dst, cur, w * df); } } } #if 0 emms_c (); #endif }
static gboolean gst_gaussianblur_set_info (GstVideoFilter * filter, GstCaps * incaps, GstVideoInfo * in_info, GstCaps * outcaps, GstVideoInfo * out_info) { GstGaussianBlur *gb = GST_GAUSSIANBLUR (filter); guint32 n_elems; gb->width = GST_VIDEO_INFO_WIDTH (in_info); gb->height = GST_VIDEO_INFO_HEIGHT (in_info); /* get stride */ gb->stride = GST_VIDEO_INFO_COMP_STRIDE (in_info, 0); n_elems = gb->stride * gb->height; gb->tempim = g_malloc (sizeof (gfloat) * n_elems); return TRUE; }
static gboolean gst_genicamsrc_set_caps (GstBaseSrc * bsrc, GstCaps * caps) { GstGenicamSrc *src = GST_GENICAM_SRC (bsrc); GstVideoInfo vinfo; GstStructure *s = gst_caps_get_structure (caps, 0); GST_DEBUG_OBJECT (src, "The caps being set are %" GST_PTR_FORMAT, caps); gst_video_info_from_caps (&vinfo, caps); if (GST_VIDEO_INFO_FORMAT (&vinfo) != GST_VIDEO_FORMAT_UNKNOWN) { src->gst_stride = GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0); } else { goto unsupported_caps; } return TRUE; unsupported_caps: GST_ERROR_OBJECT (src, "Unsupported caps: %" GST_PTR_FORMAT, caps); return FALSE; }
static GstFlowReturn gst_inter_video_src_create (GstBaseSrc * src, guint64 offset, guint size, GstBuffer ** buf) { GstInterVideoSrc *intervideosrc = GST_INTER_VIDEO_SRC (src); GstBuffer *buffer; GST_DEBUG_OBJECT (intervideosrc, "create"); buffer = NULL; g_mutex_lock (intervideosrc->surface->mutex); if (intervideosrc->surface->video_buffer) { buffer = gst_buffer_ref (intervideosrc->surface->video_buffer); intervideosrc->surface->video_buffer_count++; if (intervideosrc->surface->video_buffer_count >= 30) { gst_buffer_unref (intervideosrc->surface->video_buffer); intervideosrc->surface->video_buffer = NULL; } } g_mutex_unlock (intervideosrc->surface->mutex); if (buffer == NULL) { GstMapInfo map; buffer = gst_buffer_new_and_alloc (GST_VIDEO_INFO_SIZE (&intervideosrc->info)); gst_buffer_map (buffer, &map, GST_MAP_WRITE); memset (map.data, 16, GST_VIDEO_INFO_COMP_STRIDE (&intervideosrc->info, 0) * GST_VIDEO_INFO_COMP_HEIGHT (&intervideosrc->info, 0)); memset (map.data + GST_VIDEO_INFO_COMP_OFFSET (&intervideosrc->info, 1), 128, 2 * GST_VIDEO_INFO_COMP_STRIDE (&intervideosrc->info, 1) * GST_VIDEO_INFO_COMP_HEIGHT (&intervideosrc->info, 1)); gst_buffer_unmap (buffer, &map); } buffer = gst_buffer_make_writable (buffer); GST_BUFFER_TIMESTAMP (buffer) = gst_util_uint64_scale_int (GST_SECOND * intervideosrc->n_frames, GST_VIDEO_INFO_FPS_D (&intervideosrc->info), GST_VIDEO_INFO_FPS_N (&intervideosrc->info)); GST_DEBUG_OBJECT (intervideosrc, "create ts %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer))); GST_BUFFER_DURATION (buffer) = gst_util_uint64_scale_int (GST_SECOND * (intervideosrc->n_frames + 1), GST_VIDEO_INFO_FPS_D (&intervideosrc->info), GST_VIDEO_INFO_FPS_N (&intervideosrc->info)) - GST_BUFFER_TIMESTAMP (buffer); GST_BUFFER_OFFSET (buffer) = intervideosrc->n_frames; GST_BUFFER_OFFSET_END (buffer) = -1; GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DISCONT); if (intervideosrc->n_frames == 0) { GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT); } intervideosrc->n_frames++; *buf = buffer; return GST_FLOW_OK; }
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; }
static void gst_pvrvideosink_blit (GstPVRVideoSink * pvrvideosink, GstBuffer * buffer) { PVR2DERROR pvr_error; GstDrawContext *dcontext = pvrvideosink->dcontext; gint video_width; gint video_height; gboolean draw_border = FALSE; PPVR2D_3DBLT_EXT p_blt_3d; PVR2DMEMINFO *src_mem; PVR2DFORMAT pvr_format; GstVideoRectangle result; GstPVRMeta *meta; GstVideoCropMeta *cropmeta; GST_DEBUG_OBJECT (pvrvideosink, "buffer %p", buffer); pvr_format = GST_VIDEO_INFO_FORMAT (&pvrvideosink->info) == GST_VIDEO_FORMAT_NV12 ? PVR2D_YUV420_2PLANE : PVR2D_ARGB8888; g_mutex_lock (pvrvideosink->flow_lock); if (buffer == NULL) buffer = pvrvideosink->current_buffer; if (buffer == NULL) goto done; meta = gst_buffer_get_pvr_meta (buffer); if (G_UNLIKELY (meta == NULL)) goto no_pvr_meta; src_mem = meta->src_mem; p_blt_3d = dcontext->p_blt_info; video_width = GST_VIDEO_SINK_WIDTH (pvrvideosink); video_height = GST_VIDEO_SINK_HEIGHT (pvrvideosink); g_mutex_lock (pvrvideosink->dcontext->x_lock); /* Draw borders when displaying the first frame. After this draw borders only on expose event or after a size change. */ if (!(pvrvideosink->current_buffer) || pvrvideosink->redraw_borders) { draw_border = TRUE; } /* Store a reference to the last image we put, lose the previous one */ if (buffer && pvrvideosink->current_buffer != buffer) { if (pvrvideosink->current_buffer) { GST_LOG_OBJECT (pvrvideosink, "unreffing %p", pvrvideosink->current_buffer); gst_buffer_unref (GST_BUFFER_CAST (pvrvideosink->current_buffer)); } GST_LOG_OBJECT (pvrvideosink, "reffing %p as our current buffer", buffer); pvrvideosink->current_buffer = gst_buffer_ref (buffer); } if (pvrvideosink->keep_aspect) { GstVideoRectangle src, dst; src.w = GST_VIDEO_SINK_WIDTH (pvrvideosink); src.h = GST_VIDEO_SINK_HEIGHT (pvrvideosink); dst.w = pvrvideosink->render_rect.w; dst.h = pvrvideosink->render_rect.h; gst_video_sink_center_rect (src, dst, &result, TRUE); result.x += pvrvideosink->render_rect.x; result.y += pvrvideosink->render_rect.y; } else { memcpy (&result, &pvrvideosink->render_rect, sizeof (GstVideoRectangle)); } p_blt_3d->sDst.pSurfMemInfo = &dcontext->dst_mem; p_blt_3d->sDst.SurfOffset = 0; p_blt_3d->sDst.Stride = 4 * pvrvideosink->render_params.ui32Stride; p_blt_3d->sDst.Format = PVR2D_ARGB8888; p_blt_3d->sDst.SurfWidth = pvrvideosink->xwindow->width; p_blt_3d->sDst.SurfHeight = pvrvideosink->xwindow->height; p_blt_3d->rcDest.left = result.x; p_blt_3d->rcDest.top = result.y; p_blt_3d->rcDest.right = result.w + result.x; p_blt_3d->rcDest.bottom = result.h + result.y; p_blt_3d->sSrc.pSurfMemInfo = src_mem; p_blt_3d->sSrc.SurfOffset = 0; p_blt_3d->sSrc.Stride = GST_VIDEO_INFO_COMP_STRIDE (&pvrvideosink->info, 0); p_blt_3d->sSrc.Format = pvr_format; p_blt_3d->sSrc.SurfWidth = video_width; p_blt_3d->sSrc.SurfHeight = video_height; /* If buffer has crop information, use that */ if ((cropmeta = gst_buffer_get_video_crop_meta (buffer))) { p_blt_3d->rcSource.left = cropmeta->x; p_blt_3d->rcSource.top = cropmeta->y; p_blt_3d->rcSource.right = cropmeta->x + cropmeta->width; p_blt_3d->rcSource.bottom = cropmeta->y + cropmeta->height; } else { p_blt_3d->rcSource.left = 0; p_blt_3d->rcSource.top = 0; p_blt_3d->rcSource.right = video_width; p_blt_3d->rcSource.bottom = video_height; } p_blt_3d->hUseCode = NULL; if (GST_VIDEO_INFO_FORMAT (&pvrvideosink->info) == GST_VIDEO_FORMAT_NV12) p_blt_3d->bDisableDestInput = TRUE; else /* blit fails for RGB without this... not sure why yet... */ p_blt_3d->bDisableDestInput = FALSE; GST_DEBUG_OBJECT (pvrvideosink, "about to blit"); pvr_error = PVR2DBlt3DExt (pvrvideosink->dcontext->pvr_context, dcontext->p_blt_info); if (pvr_error != PVR2D_OK) { GST_ERROR_OBJECT (pvrvideosink, "Failed to blit. Error : %s", gst_pvr2d_error_get_string (pvr_error)); goto done; } dcontext->wsegl_table->pfnWSEGL_SwapDrawable (dcontext->drawable_handle, 1); if (draw_border) { gst_pvrvideosink_xwindow_draw_borders (pvrvideosink, pvrvideosink->xwindow, result); pvrvideosink->redraw_borders = FALSE; } g_mutex_unlock (pvrvideosink->dcontext->x_lock); done: GST_DEBUG_OBJECT (pvrvideosink, "end"); g_mutex_unlock (pvrvideosink->flow_lock); return; /* Error cases */ no_pvr_meta: { g_mutex_unlock (pvrvideosink->flow_lock); GST_ERROR_OBJECT (pvrvideosink, "Got a buffer without GstPVRMeta"); return; } }
static void gst_deinterlace_method_setup_impl (GstDeinterlaceMethod * self, GstVideoInfo * vinfo) { gint i; GstDeinterlaceMethodClass *klass = GST_DEINTERLACE_METHOD_GET_CLASS (self); self->vinfo = vinfo; self->deinterlace_frame = NULL; if (GST_VIDEO_INFO_FORMAT (self->vinfo) == GST_VIDEO_FORMAT_UNKNOWN) return; for (i = 0; i < 4; i++) { self->width[i] = GST_VIDEO_INFO_COMP_WIDTH (vinfo, i); self->height[i] = GST_VIDEO_INFO_COMP_HEIGHT (vinfo, i); self->offset[i] = GST_VIDEO_INFO_COMP_OFFSET (vinfo, i); self->row_stride[i] = GST_VIDEO_INFO_COMP_STRIDE (vinfo, i); self->pixel_stride[i] = GST_VIDEO_INFO_COMP_PSTRIDE (vinfo, i); } switch (GST_VIDEO_INFO_FORMAT (self->vinfo)) { case GST_VIDEO_FORMAT_YUY2: self->deinterlace_frame = klass->deinterlace_frame_yuy2; break; case GST_VIDEO_FORMAT_YVYU: self->deinterlace_frame = klass->deinterlace_frame_yvyu; break; case GST_VIDEO_FORMAT_UYVY: self->deinterlace_frame = klass->deinterlace_frame_uyvy; break; case GST_VIDEO_FORMAT_I420: self->deinterlace_frame = klass->deinterlace_frame_i420; break; case GST_VIDEO_FORMAT_YV12: self->deinterlace_frame = klass->deinterlace_frame_yv12; break; case GST_VIDEO_FORMAT_Y444: self->deinterlace_frame = klass->deinterlace_frame_y444; break; case GST_VIDEO_FORMAT_Y42B: self->deinterlace_frame = klass->deinterlace_frame_y42b; break; case GST_VIDEO_FORMAT_Y41B: self->deinterlace_frame = klass->deinterlace_frame_y41b; break; case GST_VIDEO_FORMAT_AYUV: self->deinterlace_frame = klass->deinterlace_frame_ayuv; break; case GST_VIDEO_FORMAT_NV12: self->deinterlace_frame = klass->deinterlace_frame_nv12; break; case GST_VIDEO_FORMAT_NV21: self->deinterlace_frame = klass->deinterlace_frame_nv21; break; case GST_VIDEO_FORMAT_ARGB: case GST_VIDEO_FORMAT_xRGB: self->deinterlace_frame = klass->deinterlace_frame_argb; break; case GST_VIDEO_FORMAT_ABGR: case GST_VIDEO_FORMAT_xBGR: self->deinterlace_frame = klass->deinterlace_frame_abgr; break; case GST_VIDEO_FORMAT_RGBA: case GST_VIDEO_FORMAT_RGBx: self->deinterlace_frame = klass->deinterlace_frame_rgba; break; case GST_VIDEO_FORMAT_BGRA: case GST_VIDEO_FORMAT_BGRx: self->deinterlace_frame = klass->deinterlace_frame_bgra; break; case GST_VIDEO_FORMAT_RGB: self->deinterlace_frame = klass->deinterlace_frame_rgb; break; case GST_VIDEO_FORMAT_BGR: self->deinterlace_frame = klass->deinterlace_frame_bgr; break; default: self->deinterlace_frame = NULL; break; } }