static void
init (GstTICaptureSrc *src, gpointer *data)
{
GST_LOG_OBJECT(src,"init start");
src->cAttrs = Capture_Attrs_DM365_DEFAULT;
src->numbufs = DEFAULT_NUM_BUFS;
src->mmap_buffer = DEFAULT_MMAP_BUFFER;
src->peer_alloc = DEFAULT_PEER_ALLOC;
src->cAttrs.colorSpace = CAPTURE_COLORSPACE;
src->fd = -1;
src->width = -1;
src->height = -1;
g_object_set(src, "device", DEFAULT_DEVICE, NULL);
g_object_set(src, "capture-input", DEFAULT_CAPTURE_INPUT, NULL);
g_object_set(src, "video-standard", DEFAULT_VIDEO_STD, NULL);
GST_LOG_OBJECT(src,"init end");
/* Initialize GValue members */
memset(&src->framerate, 0, sizeof(GValue));
g_value_init(&src->framerate, GST_TYPE_FRACTION);
g_assert(GST_VALUE_HOLDS_FRACTION(&src->framerate));
gst_value_set_fraction(&src->framerate, DEFAULT_FRAMERATE_NUM, DEFAULT_FRAMERATE_DEN);
}
static void
gst_aspect_ratio_crop_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstAspectRatioCrop *aspect_ratio_crop;
gboolean recheck = FALSE;
aspect_ratio_crop = GST_ASPECT_RATIO_CROP (object);
GST_OBJECT_LOCK (aspect_ratio_crop);
switch (prop_id) {
case ARG_ASPECT_RATIO_CROP:
if (GST_VALUE_HOLDS_FRACTION (value)) {
aspect_ratio_crop->ar_num = gst_value_get_fraction_numerator (value);
aspect_ratio_crop->ar_denom =
gst_value_get_fraction_denominator (value);
recheck = (GST_PAD_CAPS (aspect_ratio_crop->sink) != NULL);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
GST_OBJECT_UNLOCK (aspect_ratio_crop);
if (recheck) {
gst_aspect_ratio_crop_set_caps (aspect_ratio_crop->sink,
GST_PAD_CAPS (aspect_ratio_crop->sink));
}
}
static void
get_supported_framerates (ofGstVideoFormat &video_format, GstStructure &structure)
{
const GValue *framerates;
int i, j;
framerates = gst_structure_get_value (&structure, "framerate");
if (GST_VALUE_HOLDS_FRACTION (framerates))
{
video_format.num_framerates = 1;
video_format.framerates = new ofGstFramerate[video_format.num_framerates];
video_format.framerates[0].numerator = gst_value_get_fraction_numerator (framerates);
video_format.framerates[0].denominator = gst_value_get_fraction_denominator (framerates);
}
else if (GST_VALUE_HOLDS_LIST (framerates))
{
video_format.num_framerates = gst_value_list_get_size (framerates);
video_format.framerates = new ofGstFramerate[video_format.num_framerates];
for (i = 0; i < video_format.num_framerates; i++)
{
const GValue *value;
value = gst_value_list_get_value (framerates, i);
video_format.framerates[i].numerator = gst_value_get_fraction_numerator (value);
video_format.framerates[i].denominator = gst_value_get_fraction_denominator (value);
}
}
else if (GST_VALUE_HOLDS_FRACTION_RANGE (framerates))
{
int numerator_min, denominator_min, numerator_max, denominator_max;
const GValue *fraction_range_min;
const GValue *fraction_range_max;
fraction_range_min = gst_value_get_fraction_range_min (framerates);
numerator_min = gst_value_get_fraction_numerator (fraction_range_min);
denominator_min = gst_value_get_fraction_denominator (fraction_range_min);
fraction_range_max = gst_value_get_fraction_range_max (framerates);
numerator_max = gst_value_get_fraction_numerator (fraction_range_max);
denominator_max = gst_value_get_fraction_denominator (fraction_range_max);
g_print ("FractionRange: %d/%d - %d/%d\n", numerator_min, denominator_min, numerator_max, denominator_max);
video_format.num_framerates = (numerator_max - numerator_min + 1) * (denominator_max - denominator_min + 1);
video_format.framerates = new ofGstFramerate[video_format.num_framerates];
int k = 0;
for (i = numerator_min; i <= numerator_max; i++)
{
for (j = denominator_min; j <= denominator_max; j++)
{
video_format.framerates[k].numerator = i;
video_format.framerates[k].denominator = j;
k++;
}
}
}
else
{
g_critical ("GValue type %s, cannot be handled for framerates", G_VALUE_TYPE_NAME (framerates));
}
}
bool ofGstVideoPlayer::allocate(int bpp){
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,bpp)) 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)){
if(!videoUtils.allocate(info.width,info.height,bpp)) 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 gboolean
sink_setcaps (GstPad *pad,
GstCaps *caps)
{
GstStructure *structure;
GstOmxBaseFilter21 *self;
GOmxCore *gomx;
GstVideoFormat format;
int sink_number;
self = GST_OMX_BASE_FILTER21 (GST_PAD_PARENT (pad));
if(strcmp(GST_PAD_NAME(pad), "sink_00") == 0){
sink_number=0;
}
else if(strcmp(GST_PAD_NAME(pad), "sink_01") == 0){
sink_number=1;
}
gomx = (GOmxCore *) self->gomx;
GST_INFO_OBJECT (self, "setcaps (sink): %d", sink_number);
GST_INFO_OBJECT (self, "setcaps (sink): %" GST_PTR_FORMAT, caps);
g_return_val_if_fail (caps, FALSE);
g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE);
structure = gst_caps_get_structure (caps, 0);
g_return_val_if_fail (structure, FALSE);
if (!gst_video_format_parse_caps_strided (caps,
&format, &self->in_width[sink_number], &self->in_height[sink_number], &self->in_stride[sink_number]))
{
GST_WARNING_OBJECT (self, "width and/or height is not set in caps");
return FALSE;
}
if (!self->in_stride[sink_number])
{
self->in_stride[sink_number] = gstomx_calculate_stride (self->in_width[sink_number], format);
}
{
/* Output framerate correspond to the minimum input framerate */
const GValue *sink_framerate = NULL;
sink_framerate = gst_structure_get_value (structure, "framerate");
if( GST_VALUE_HOLDS_FRACTION(sink_framerate) )
{
if( self->out_framerate == NULL || gst_value_compare(sink_framerate, self->out_framerate) == GST_VALUE_LESS_THAN )
{
self->out_framerate = sink_framerate;
self->duration = gst_util_uint64_scale_int(GST_SECOND, gst_value_get_fraction_denominator(sink_framerate),
gst_value_get_fraction_numerator(sink_framerate));
}
}
}
return gst_pad_set_caps (pad, caps);
}
static void
_get_fraction_range (GstStructure * s, const gchar * field, gint * fps_n_min,
gint * fps_d_min, gint * fps_n_max, gint * fps_d_max)
{
const GValue *value;
const GValue *min_v, *max_v;
value = gst_structure_get_value (s, field);
fail_unless (value != NULL);
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (value));
min_v = gst_value_get_fraction_range_min (value);
fail_unless (GST_VALUE_HOLDS_FRACTION (min_v));
*fps_n_min = gst_value_get_fraction_numerator (min_v);
*fps_d_min = gst_value_get_fraction_denominator (min_v);
max_v = gst_value_get_fraction_range_max (value);
fail_unless (GST_VALUE_HOLDS_FRACTION (max_v));
*fps_n_max = gst_value_get_fraction_numerator (max_v);
*fps_d_max = gst_value_get_fraction_denominator (max_v);
}
static void
gst_value_fraction_get_extremes (const GValue * v,
gint * min_num, gint * min_denom, gint * max_num, gint * max_denom)
{
if (GST_VALUE_HOLDS_FRACTION (v)) {
*min_num = *max_num = gst_value_get_fraction_numerator (v);
*min_denom = *max_denom = gst_value_get_fraction_denominator (v);
} else if (GST_VALUE_HOLDS_FRACTION_RANGE (v)) {
const GValue *min, *max;
min = gst_value_get_fraction_range_min (v);
*min_num = gst_value_get_fraction_numerator (min);
*min_denom = gst_value_get_fraction_denominator (min);
max = gst_value_get_fraction_range_max (v);
*max_num = gst_value_get_fraction_numerator (max);
*max_denom = gst_value_get_fraction_denominator (max);
} else if (GST_VALUE_HOLDS_LIST (v)) {
gint min_n = G_MAXINT, min_d = 1, max_n = 0, max_d = 1;
int i, n;
*min_num = G_MAXINT;
*min_denom = 1;
*max_num = 0;
*max_denom = 1;
n = gst_value_list_get_size (v);
g_assert (n > 0);
for (i = 0; i < n; i++) {
const GValue *t = gst_value_list_get_value (v, i);
gst_value_fraction_get_extremes (t, &min_n, &min_d, &max_n, &max_d);
if (gst_util_fraction_compare (min_n, min_d, *min_num, *min_denom) < 0) {
*min_num = min_n;
*min_denom = min_d;
}
if (gst_util_fraction_compare (max_n, max_d, *max_num, *max_denom) > 0) {
*max_num = max_n;
*max_denom = max_d;
}
}
} else {
g_warning ("Unknown type for framerate");
*min_num = 0;
*min_denom = 1;
*max_num = G_MAXINT;
*max_denom = 1;
}
}
static void get_supported_framerates (ofGstVideoFormat &video_format, GstStructure &structure)
{
const GValue *framerates;
ofGstFramerate framerate;
framerates = gst_structure_get_value (&structure, "framerate");
if (GST_VALUE_HOLDS_FRACTION (framerates)){
framerate.numerator = gst_value_get_fraction_numerator (framerates);
framerate.denominator = gst_value_get_fraction_denominator (framerates);
video_format.framerates.push_back(framerate);
ofLog(OF_LOG_NOTICE,"%d/%d ", framerate.numerator,
framerate.denominator);
}else if (GST_VALUE_HOLDS_LIST (framerates)){
int num_framerates = gst_value_list_get_size (framerates);
for (int i = 0; i < num_framerates; i++){
const GValue *value = gst_value_list_get_value (framerates, i);
framerate.numerator = gst_value_get_fraction_numerator (value);
framerate.denominator = gst_value_get_fraction_denominator (value);
video_format.framerates.push_back(framerate);
ofLog(OF_LOG_NOTICE,"%d/%d ", framerate.numerator,
framerate.denominator);
}
}else if (GST_VALUE_HOLDS_FRACTION_RANGE (framerates)){
int numerator_min, denominator_min, numerator_max, denominator_max;
const GValue *fraction_range_min;
const GValue *fraction_range_max;
fraction_range_min = gst_value_get_fraction_range_min (framerates);
numerator_min = gst_value_get_fraction_numerator (fraction_range_min);
denominator_min = gst_value_get_fraction_denominator (fraction_range_min);
fraction_range_max = gst_value_get_fraction_range_max (framerates);
numerator_max = gst_value_get_fraction_numerator (fraction_range_max);
denominator_max = gst_value_get_fraction_denominator (fraction_range_max);
ofLog(OF_LOG_NOTICE,"from %d/%d to %d/%d", numerator_min,
denominator_max, numerator_max, denominator_min);
for (int i = numerator_min; i <= numerator_max; i++){
for (int j = denominator_min; j <= denominator_max; j++){
framerate.numerator = i;
framerate.denominator = j;
video_format.framerates.push_back(framerate);
}
}
}else{
ofLog (OF_LOG_WARNING,"unknown GValue type %s for framerates", G_VALUE_TYPE_NAME (framerates));
}
}
static gboolean
gst_mill_color_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
GstCaps * outcaps)
{
GstMillColor *mc;
GstStructure *structure;
gboolean ret;
const GValue *fps;
gint red_mask, alpha_mask;
gint w, h, depth, bpp;
mc = GST_MILL_COLOR (btrans);
structure = gst_caps_get_structure (incaps, 0);
ret = gst_structure_get_int (structure, "width", &w);
ret &= gst_structure_get_int (structure, "height", &h);
fps = gst_structure_get_value (structure, "framerate");
ret &= (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps));
ret &= gst_structure_get_int (structure, "red_mask", &red_mask);
/* make sure these are really full RGBA caps */
ret &= gst_structure_get_int (structure, "alpha_mask", &alpha_mask);
ret &= gst_structure_get_int (structure, "depth", &depth);
ret &= gst_structure_get_int (structure, "bpp", &bpp);
if (!ret || alpha_mask == 0 || red_mask == 0 || depth != 32 || bpp != 32) {
GST_DEBUG_OBJECT (mc, "incomplete or non-RGBA input caps!");
return FALSE;
}
mc->in_width = w;
mc->in_height = h;
mc->in_rgba = TRUE;
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
if (red_mask != 0x000000ff)
#else
if (red_mask != 0xff000000)
#endif
mc->in_rgba = FALSE;
return TRUE;
}
static gboolean
gst_jpeg_parse_sink_setcaps (GstJpegParse * parse, GstCaps * caps)
{
GstStructure *s = gst_caps_get_structure (caps, 0);
const GValue *framerate;
if ((framerate = gst_structure_get_value (s, "framerate")) != NULL) {
if (GST_VALUE_HOLDS_FRACTION (framerate)) {
parse->priv->framerate_numerator =
gst_value_get_fraction_numerator (framerate);
parse->priv->framerate_denominator =
gst_value_get_fraction_denominator (framerate);
parse->priv->has_fps = TRUE;
GST_DEBUG_OBJECT (parse, "got framerate of %d/%d",
parse->priv->framerate_numerator, parse->priv->framerate_denominator);
}
}
return TRUE;
}
EXPORT_C
#endif
const GValue *
gst_video_frame_rate (GstPad * pad)
{
const GValue *fps;
gchar *fps_string;
const GstCaps *caps = NULL;
GstStructure *structure;
/* get pad caps */
caps = GST_PAD_CAPS (pad);
if (caps == NULL) {
g_warning ("gstvideo: failed to get caps of pad %s:%s",
GST_DEBUG_PAD_NAME (pad));
return NULL;
}
structure = gst_caps_get_structure (caps, 0);
if ((fps = gst_structure_get_value (structure, "framerate")) == NULL) {
g_warning ("gstvideo: failed to get framerate property of pad %s:%s",
GST_DEBUG_PAD_NAME (pad));
return NULL;
}
if (!GST_VALUE_HOLDS_FRACTION (fps)) {
g_warning
("gstvideo: framerate property of pad %s:%s is not of type Fraction",
GST_DEBUG_PAD_NAME (pad));
return NULL;
}
fps_string = gst_value_serialize (fps);
GST_DEBUG ("Framerate request on pad %s:%s: %s",
GST_DEBUG_PAD_NAME (pad), fps_string);
g_free (fps_string);
return fps;
}
static GUPnPDLNAFractionValue
get_fraction_value_from_tag_list (const GstTagList *tags,
const gchar *name)
{
GUPnPDLNAFractionValue value = GUPNP_DLNA_FRACTION_VALUE_UNSET;
if (tags != NULL) {
const GValue *g_value = gst_tag_list_get_value_index (tags,
name,
0);
if (g_value != NULL && GST_VALUE_HOLDS_FRACTION (g_value)) {
value.state = GUPNP_DLNA_VALUE_STATE_SET;
value.numerator =
gst_value_get_fraction_numerator (g_value);
value.denominator =
gst_value_get_fraction_denominator (g_value);
}
}
return value;
}
bool ofGstVideoPlayer::allocate(int bpp){
if(bIsAllocated) return true;
guint64 durationNanos = videoUtils.getDurationNanos();
nFrames = 0;
if(GstPad* pad = gst_element_get_static_pad(videoUtils.getSink(), "sink")){
int width,height;
if(gst_video_get_size(GST_PAD(pad), &width, &height)){
if(!videoUtils.allocate(width,height,bpp)) return false;
}else{
ofLog(OF_LOG_ERROR,"GStreamer: cannot query width and height");
return false;
}
const GValue *framerate;
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 / GST_SECOND) * (float)fps_n/(float)fps_d;
ofLog(OF_LOG_VERBOSE,"ofGstUtils: framerate: %i/%i",fps_n,fps_d);
}else{
ofLog(OF_LOG_WARNING,"Gstreamer: cannot get framerate, frame seek won't work");
}
gst_object_unref(GST_OBJECT(pad));
bIsAllocated = true;
}else{
ofLog(OF_LOG_ERROR,"GStreamer: cannot get sink pad");
bIsAllocated = false;
}
return bIsAllocated;
}
// possible values in GstCaps are:
// width
// height
// format
// framerate
bool ExtractImageParams(GstCaps *caps, int & width, int & height, PixelFormat & pixelFormat)
{
width = height = 0;
pixelFormat = PF__UNKNOWN;
char text[4000];
text[0] = 0;
strcat_s(text, "\r\n\r\n");
for (unsigned int j = 0; j < gst_caps_get_size(caps); ++j)
{
GstStructure * structure = gst_caps_get_structure(caps, j);
for (int i = 0; i < gst_structure_n_fields(structure); ++i)
{
const char * name = gst_structure_nth_field_name(structure, i);
GType type = gst_structure_get_field_type(structure, name);
const GValue * value = gst_structure_get_value(structure, name);
if (strcmp("width", name) == 0)
{
width = value->data->v_int;
}
if (strcmp("height", name) == 0)
{
height = value->data->v_int;
}
if (strcmp("format", name) == 0)
{
const gchar * format = g_value_get_string(value);
if (strcmp(format, "RGB") == 0)
pixelFormat = PF__RGB;
else if (strcmp(format, "BGR") == 0)
pixelFormat = PF__BGR;
else if (strcmp(format, "I420") == 0)
pixelFormat = PF__I420;
}
strcat_s(text, name);
strcat_s(text, "[");
strcat_s(text, g_type_name(type));
strcat_s(text, ":");
if (g_type_is_a(type, G_TYPE_STRING))
strcat_s(text, g_value_get_string(value));
else if (GST_VALUE_HOLDS_FRACTION(&type))
{
char size[100];
sprintf_s(size, "%d/%d", value->data[0].v_int, value->data[1].v_int);
strcat_s(text, size);
}
else
{
char size[100];
sprintf_s(size, "%d", value->data->v_int);
strcat_s(text, size);
}
strcat(text ,"]\r\n");
}
printf(text);
}
return width > 0 && height > 0 && pixelFormat != PF__UNKNOWN;
}
static gboolean
gst_xvidenc_setcaps (GstPad * pad, GstCaps * vscaps)
{
GstXvidEnc *xvidenc;
GstStructure *structure;
gint w, h;
const GValue *fps, *par;
gint xvid_cs = -1;
xvidenc = GST_XVIDENC (GST_PAD_PARENT (pad));
/* if there's something old around, remove it */
if (xvidenc->handle) {
gst_xvidenc_flush_buffers (xvidenc, TRUE);
xvid_encore (xvidenc->handle, XVID_ENC_DESTROY, NULL, NULL);
xvidenc->handle = NULL;
}
structure = gst_caps_get_structure (vscaps, 0);
if (!gst_structure_get_int (structure, "width", &w) ||
!gst_structure_get_int (structure, "height", &h)) {
return FALSE;
}
fps = gst_structure_get_value (structure, "framerate");
if (fps == NULL || !GST_VALUE_HOLDS_FRACTION (fps)) {
GST_WARNING_OBJECT (pad, "no framerate specified, or not a GstFraction");
return FALSE;
}
/* optional par info */
par = gst_structure_get_value (structure, "pixel-aspect-ratio");
xvid_cs = gst_xvid_structure_to_csp (structure);
if (xvid_cs == -1) {
gchar *sstr;
sstr = gst_structure_to_string (structure);
GST_DEBUG_OBJECT (xvidenc, "Did not find xvid colourspace for caps %s",
sstr);
g_free (sstr);
return FALSE;
}
xvidenc->csp = xvid_cs;
xvidenc->width = w;
xvidenc->height = h;
xvidenc->fbase = gst_value_get_fraction_numerator (fps);
xvidenc->fincr = gst_value_get_fraction_denominator (fps);
if ((par != NULL) && GST_VALUE_HOLDS_FRACTION (par)) {
xvidenc->par_width = gst_value_get_fraction_numerator (par);
xvidenc->par_height = gst_value_get_fraction_denominator (par);
} else {
xvidenc->par_width = 1;
xvidenc->par_height = 1;
}
/* wipe xframe cache given possible change caps properties */
g_free (xvidenc->xframe_cache);
xvidenc->xframe_cache = NULL;
if (gst_xvidenc_setup (xvidenc)) {
gboolean ret = FALSE;
GstCaps *new_caps = NULL, *allowed_caps;
/* please downstream with preferred caps */
allowed_caps = gst_pad_get_allowed_caps (xvidenc->srcpad);
GST_DEBUG_OBJECT (xvidenc, "allowed caps: %" GST_PTR_FORMAT, allowed_caps);
if (allowed_caps && !gst_caps_is_empty (allowed_caps)) {
new_caps = gst_caps_copy_nth (allowed_caps, 0);
} else {
new_caps = gst_caps_new_simple ("video/x-xvid", NULL);
}
if (allowed_caps)
gst_caps_unref (allowed_caps);
gst_caps_set_simple (new_caps,
"width", G_TYPE_INT, w, "height", G_TYPE_INT, h,
"framerate", GST_TYPE_FRACTION, xvidenc->fbase, xvidenc->fincr,
"pixel-aspect-ratio", GST_TYPE_FRACTION,
xvidenc->par_width, xvidenc->par_height, NULL);
/* just to be sure */
gst_pad_fixate_caps (xvidenc->srcpad, new_caps);
if (xvidenc->used_profile != 0) {
switch (xvidenc->used_profile) {
case XVID_PROFILE_S_L0:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING, "simple",
"level", G_TYPE_STRING, "0", NULL);
break;
case XVID_PROFILE_S_L1:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING, "simple",
"level", G_TYPE_STRING, "1", NULL);
break;
case XVID_PROFILE_S_L2:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING, "simple",
"level", G_TYPE_STRING, "2", NULL);
break;
case XVID_PROFILE_S_L3:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING, "simple",
"level", G_TYPE_STRING, "3", NULL);
break;
/* case XVID_PROFILE_S_L4a:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING, "simple",
"level", G_TYPE_STRING, "4a", NULL);
break;
case XVID_PROFILE_S_L5:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING, "simple",
"level", G_TYPE_STRING, "5", NULL);
break;
case XVID_PROFILE_S_L6:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING, "simple",
"level", G_TYPE_STRING, "6", NULL);
break;*/
case XVID_PROFILE_ARTS_L1:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-real-time-simple", "level", G_TYPE_STRING, "1", NULL);
break;
case XVID_PROFILE_ARTS_L2:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-real-time-simple", "level", G_TYPE_STRING, "2", NULL);
break;
case XVID_PROFILE_ARTS_L3:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-real-time-simple", "level", G_TYPE_STRING, "3", NULL);
break;
case XVID_PROFILE_ARTS_L4:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-real-time-simple", "level", G_TYPE_STRING, "4", NULL);
break;
case XVID_PROFILE_AS_L0:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-simple", "level", G_TYPE_STRING, "0", NULL);
break;
case XVID_PROFILE_AS_L1:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-simple", "level", G_TYPE_STRING, "1", NULL);
break;
case XVID_PROFILE_AS_L2:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-simple", "level", G_TYPE_STRING, "2", NULL);
break;
case XVID_PROFILE_AS_L3:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-simple", "level", G_TYPE_STRING, "3", NULL);
break;
case XVID_PROFILE_AS_L4:
gst_caps_set_simple (new_caps, "profile", G_TYPE_STRING,
"advanced-simple", "level", G_TYPE_STRING, "4", NULL);
break;
default:
g_assert_not_reached ();
break;
}
}
/* src pad should accept anyway */
ret = gst_pad_set_caps (xvidenc->srcpad, new_caps);
gst_caps_unref (new_caps);
if (!ret && xvidenc->handle) {
xvid_encore (xvidenc->handle, XVID_ENC_DESTROY, NULL, NULL);
xvidenc->handle = NULL;
}
return ret;
} else /* setup did not work out */
return FALSE;
}
static gboolean
gst_xviddec_setcaps (GstPad * pad, GstCaps * caps)
{
GstXvidDec *dec = GST_XVIDDEC (GST_PAD_PARENT (pad));
GstStructure *structure;
GstCaps *allowed_caps;
const GValue *val;
GST_LOG_OBJECT (dec, "caps %" GST_PTR_FORMAT, caps);
/* if there's something old around, remove it */
if (dec->handle) {
gst_xviddec_unset (dec);
}
structure = gst_caps_get_structure (caps, 0);
gst_structure_get_int (structure, "width", &dec->width);
gst_structure_get_int (structure, "height", &dec->height);
/* perhaps some fps info */
val = gst_structure_get_value (structure, "framerate");
if ((val != NULL) && GST_VALUE_HOLDS_FRACTION (val)) {
dec->fps_n = gst_value_get_fraction_numerator (val);
dec->fps_d = gst_value_get_fraction_denominator (val);
} else {
dec->fps_n = -1;
dec->fps_d = 1;
}
/* perhaps some par info */
val = gst_structure_get_value (structure, "pixel-aspect-ratio");
if (val != NULL && GST_VALUE_HOLDS_FRACTION (val)) {
dec->par_n = gst_value_get_fraction_numerator (val);
dec->par_d = gst_value_get_fraction_denominator (val);
} else {
dec->par_n = 1;
dec->par_d = 1;
}
/* we try to find the preferred/accept csp */
allowed_caps = gst_pad_get_allowed_caps (dec->srcpad);
if (!allowed_caps) {
GST_DEBUG_OBJECT (dec, "... but no peer, using template caps");
/* need to copy because get_allowed_caps returns a ref,
and get_pad_template_caps doesn't */
allowed_caps = gst_caps_copy (gst_pad_get_pad_template_caps (dec->srcpad));
}
GST_LOG_OBJECT (dec, "allowed source caps %" GST_PTR_FORMAT, allowed_caps);
/* pick the first one ... */
structure = gst_caps_get_structure (allowed_caps, 0);
val = gst_structure_get_value (structure, "format");
if (val != NULL && G_VALUE_TYPE (val) == GST_TYPE_LIST) {
GValue temp = { 0, };
gst_value_init_and_copy (&temp, gst_value_list_get_value (val, 0));
gst_structure_set_value (structure, "format", &temp);
g_value_unset (&temp);
}
/* ... and use its info to get the csp */
dec->csp = gst_xvid_structure_to_csp (structure);
if (dec->csp == -1) {
GST_WARNING_OBJECT (dec, "failed to decide on colorspace, using I420");
dec->csp = XVID_CSP_I420;
}
dec->outbuf_size =
gst_xvid_image_get_size (dec->csp, dec->width, dec->height);
GST_LOG_OBJECT (dec, "csp=%d, outbuf_size=%d", dec->csp, dec->outbuf_size);
gst_caps_unref (allowed_caps);
/* now set up xvid ... */
if (!gst_xviddec_setup (dec)) {
GST_ELEMENT_ERROR (GST_ELEMENT (dec), LIBRARY, INIT, (NULL), (NULL));
return FALSE;
}
return gst_xviddec_negotiate (dec, NULL);
}
/*
* cheese_camera_device_get_highest_framerate:
* @framerate: a #GValue holding a framerate cap
* @numerator: destination to store the numerator of the highest rate
* @denominator: destination to store the denominator of the highest rate
*
* Get the numerator and denominator for the highest framerate stored in
* a framerate cap.
*
* Note this function does not handle framerate ranges, if @framerate
* contains a range it will return 0/0 as framerate
*/
static void
cheese_camera_device_get_highest_framerate (const GValue *framerate,
gint *numerator, gint *denominator)
{
*numerator = 0;
*denominator = 0;
if (GST_VALUE_HOLDS_FRACTION (framerate))
{
*numerator = gst_value_get_fraction_numerator (framerate);
*denominator = gst_value_get_fraction_denominator (framerate);
}
else if (GST_VALUE_HOLDS_ARRAY (framerate))
{
float curr, highest = 0;
guint i, size = gst_value_array_get_size (framerate);
for (i = 0; i < size; i++)
{
const GValue *val = gst_value_array_get_value (framerate, i);
if (!GST_VALUE_HOLDS_FRACTION (val) ||
gst_value_get_fraction_denominator (val) == 0) {
continue;
}
curr = (float)gst_value_get_fraction_numerator (val) /
(float)gst_value_get_fraction_denominator (val);
if (curr > highest && curr <= CHEESE_MAXIMUM_RATE)
{
highest = curr;
*numerator = gst_value_get_fraction_numerator (val);
*denominator = gst_value_get_fraction_denominator (val);
}
}
}
else if (GST_VALUE_HOLDS_LIST (framerate))
{
float curr, highest = 0;
guint i, size = gst_value_list_get_size (framerate);
for (i = 0; i < size; i++)
{
const GValue *val = gst_value_list_get_value(framerate, i);
if (!GST_VALUE_HOLDS_FRACTION (val) ||
gst_value_get_fraction_denominator (val) == 0)
{
continue;
}
curr = (float)gst_value_get_fraction_numerator (val) /
(float)gst_value_get_fraction_denominator (val);
if (curr > highest && curr <= CHEESE_MAXIMUM_RATE)
{
highest = curr;
*numerator = gst_value_get_fraction_numerator (val);
*denominator = gst_value_get_fraction_denominator (val);
}
}
}
}
bool ofGstUtils::allocate(){
// wait for paused state to query the duration
if(!bIsStream){
GstState state = GST_STATE_PAUSED;
gst_element_get_state(gstPipeline,&state,NULL,2*GST_SECOND);
}
if(!bIsCamera){
GstFormat format=GST_FORMAT_TIME;
if(!gst_element_query_duration(gstPipeline,&format,&durationNanos))
ofLog(OF_LOG_WARNING,"GStreamer: cannot query time duration");
gstData.durationNanos = durationNanos;
gstData.nFrames = 0;
}
// query width, height, fps and do data allocation
if (bIsCamera) {
pixels=new unsigned char[width*height*bpp];
gstData.pixels=new unsigned char[width*height*bpp];
memset(pixels,0,width*height*bpp);
memset(gstData.pixels,0,width*height*bpp);
gstData.width = width;
gstData.height = height;
gstData.totalsize = 0;
gstData.lastFrame = 0;
}else if(gstSink!=NULL){
if(GstPad* pad = gst_element_get_static_pad(gstSink, "sink")){
if(gst_video_get_size(GST_PAD(pad), &width, &height)){
pixels=new unsigned char[width*height*bpp];
gstData.pixels=new unsigned char[width*height*bpp];;
memset(pixels,0,width*height*bpp);
memset(gstData.pixels,0,width*height*bpp);
gstData.width = width;
gstData.height = height;
gstData.totalsize = 0;
gstData.lastFrame = 0;
}else{
ofLog(OF_LOG_ERROR,"GStreamer: cannot query width and height");
return false;
}
const GValue *framerate;
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);
gstData.nFrames = (float)(durationNanos / GST_SECOND) * (float)fps_n/(float)fps_d;
ofLog(OF_LOG_VERBOSE,"ofGstUtils: framerate: %i/%i",fps_n,fps_d);
}else{
ofLog(OF_LOG_WARNING,"Gstreamer: cannot get framerate, frame seek won't work");
}
gst_object_unref(GST_OBJECT(pad));
}else{
ofLog(OF_LOG_ERROR,"GStreamer: cannot get sink pad");
return false;
}
}
bLoaded = true;
bHavePixelsChanged = true;
bStarted = true;
return bLoaded;
}
static gboolean
gst_divxenc_setcaps (GstPad * pad, GstCaps * caps)
{
GstDivxEnc *divxenc;
GstStructure *structure = gst_caps_get_structure (caps, 0);
gint w, h;
const GValue *fps;
guint32 fourcc;
guint32 divx_cs;
gint bitcnt = 0;
gboolean ret = FALSE;
divxenc = GST_DIVXENC (gst_pad_get_parent (pad));
/* if there's something old around, remove it */
gst_divxenc_unset (divxenc);
gst_structure_get_int (structure, "width", &w);
gst_structure_get_int (structure, "height", &h);
gst_structure_get_fourcc (structure, "format", &fourcc);
fps = gst_structure_get_value (structure, "framerate");
if (fps != NULL && GST_VALUE_HOLDS_FRACTION (fps)) {
divxenc->fps_n = gst_value_get_fraction_numerator (fps);
divxenc->fps_d = gst_value_get_fraction_denominator (fps);
} else {
divxenc->fps_n = -1;
}
switch (fourcc) {
case GST_MAKE_FOURCC ('I', '4', '2', '0'):
divx_cs = GST_MAKE_FOURCC ('I', '4', '2', '0');
break;
case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
divx_cs = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
break;
case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
divx_cs = GST_MAKE_FOURCC ('Y', 'V', '1', '2');
break;
case GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U'):
divx_cs = GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U');
break;
case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
divx_cs = GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y');
break;
default:
ret = FALSE;
goto done;
}
divxenc->csp = divx_cs;
divxenc->bitcnt = bitcnt;
divxenc->width = w;
divxenc->height = h;
/* try it */
if (gst_divxenc_setup (divxenc)) {
GstCaps *new_caps = NULL;
new_caps = gst_caps_new_simple ("video/x-divx",
"divxversion", G_TYPE_INT, 5,
"width", G_TYPE_INT, w,
"height", G_TYPE_INT, h,
"framerate", GST_TYPE_FRACTION, divxenc->fps_n, divxenc->fps_d, NULL);
if (new_caps) {
if (!gst_pad_set_caps (divxenc->srcpad, new_caps)) {
gst_divxenc_unset (divxenc);
ret = FALSE;
goto done;
}
gst_caps_unref (new_caps);
ret = TRUE;
goto done;
}
}
/* if we got here - it's not good */
ret = FALSE;
done:
gst_object_unref (divxenc);
return ret;
}
static gboolean
gst_y4m_encode_setcaps (GstPad * pad, GstCaps * vscaps)
{
GstY4mEncode *filter;
GstStructure *structure;
gboolean res;
gint w, h;
guint32 fourcc;
const GValue *fps, *par, *interlaced;
filter = GST_Y4M_ENCODE (GST_PAD_PARENT (pad));
structure = gst_caps_get_structure (vscaps, 0);
res = gst_structure_get_int (structure, "width", &w);
res &= gst_structure_get_int (structure, "height", &h);
res &= ((fps = gst_structure_get_value (structure, "framerate")) != NULL);
res &= gst_structure_get_fourcc (structure, "format", &fourcc);
switch (fourcc) { /* Translate fourcc to Y4M colorspace code */
case GST_MAKE_FOURCC ('I', '4', '2', '0'):
case GST_MAKE_FOURCC ('I', 'Y', 'U', 'V'):
filter->colorspace = "420";
break;
case GST_MAKE_FOURCC ('Y', '4', '2', 'B'):
filter->colorspace = "422";
break;
case GST_MAKE_FOURCC ('Y', '4', '1', 'B'):
filter->colorspace = "411";
break;
case GST_MAKE_FOURCC ('Y', '4', '4', '4'):
filter->colorspace = "444";
break;
default:
res = FALSE;
break;
}
if (!res || w <= 0 || h <= 0 || !GST_VALUE_HOLDS_FRACTION (fps))
return FALSE;
/* optional interlaced info */
interlaced = gst_structure_get_value (structure, "interlaced");
/* optional par info */
par = gst_structure_get_value (structure, "pixel-aspect-ratio");
filter->width = w;
filter->height = h;
filter->fps_num = gst_value_get_fraction_numerator (fps);
filter->fps_den = gst_value_get_fraction_denominator (fps);
if ((par != NULL) && GST_VALUE_HOLDS_FRACTION (par)) {
filter->par_num = gst_value_get_fraction_numerator (par);
filter->par_den = gst_value_get_fraction_denominator (par);
} else { /* indicates unknown */
filter->par_num = 0;
filter->par_den = 0;
}
if ((interlaced != NULL) && G_VALUE_HOLDS (interlaced, G_TYPE_BOOLEAN)) {
filter->interlaced = g_value_get_boolean (interlaced);
} else {
/* assume progressive if no interlaced property in caps */
filter->interlaced = FALSE;
}
/* the template caps will do for the src pad, should always accept */
return gst_pad_set_caps (filter->srcpad,
gst_static_pad_template_get_caps (&y4mencode_src_factory));
}