gst/debugutils/progressreport.c

   1 /* GStreamer Progress Report Element
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) <2003> David Schleef <ds@schleef.org>
   4  * Copyright (C) <2004> Jan Schmidt <thaytan@mad.scientist.com>
   5  * Copyright (C) <2006> Tim-Philipp Müller <tim centricular net>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /**
  24  * SECTION:element-progressreport
  25  *
  26  * The progressreport element can be put into a pipeline to report progress,
  27  * which is done by doing upstream duration and position queries in regular
  28  * (real-time) intervals. Both the interval and the prefered query format
  29  * can be specified via the #GstProgressReport:update-freq and the
  30  * #GstProgressReport:format property.
  31  *
  32  * Element messages containing a "progress" structure are posted on the bus
  33  * whenever progress has been queried (since gst-plugins-good 0.10.6 only).
  34  *
  35  * Since the element was originally designed for debugging purposes, it will
  36  * by default also print information about the current progress to the
  37  * terminal. This can be prevented by setting the #GstProgressReport:silent
  38  * property to %TRUE.
  39  *
  40  * This element is most useful in transcoding pipelines or other situations
  41  * where just querying the pipeline might not lead to the wanted result. For
  42  * progress in TIME format, the element is best placed in a 'raw stream'
  43  * section of the pipeline (or after any demuxers/decoders/parsers).
  44  *
  45  * Three more things should be pointed out: firstly, the element will only
  46  * query progress when data flow happens. If data flow is stalled for some
  47  * reason, no progress messages will be posted. Secondly, there are other
  48  * elements (like qtdemux, for example) that may also post "progress" element
  49  * messages on the bus. Applications should check the source of any element
  50  * messages they receive, if needed. Finally, applications should not take
  51  * action on receiving notification of progress being 100%, they should only
  52  * take action when they receive an EOS message (since the progress reported
  53  * is in reference to an internal point of a pipeline and not the pipeline as
  54  * a whole).
  55  *
  56  * <refsect2>
  57  * <title>Example launch line</title>
  58  * |[
  59  * gst-launch -m filesrc location=foo.ogg ! decodebin ! progressreport update-freq=1 ! audioconvert ! audioresample ! autoaudiosink
  60  * ]| This shows a progress query where a duration is available.
  61  * |[
  62  * gst-launch -m audiotestsrc ! progressreport update-freq=1 ! audioconvert ! autoaudiosink
  63  * ]| This shows a progress query where no duration is available.
  64  * </refsect2>
  65  */
  66
  67 #ifdef HAVE_CONFIG_H
  68 #include "config.h"
  69 #endif
  70
  71 #include <gst/gst.h>
  72 #include <string.h>
  73 #include <math.h>
  74 #include <time.h>
  75
  76 #include "progressreport.h"
  77
  78
  79 enum
  80 {
  81   ARG_0,
  82   ARG_UPDATE_FREQ,
  83   ARG_SILENT,
  84   ARG_DO_QUERY,
  85   ARG_FORMAT
  86 };
  87
  88 GstStaticPadTemplate progress_report_src_template =
  89 GST_STATIC_PAD_TEMPLATE ("src",
  90     GST_PAD_SRC,
  91     GST_PAD_ALWAYS,
  92     GST_STATIC_CAPS_ANY);
  93
  94 GstStaticPadTemplate progress_report_sink_template =
  95 GST_STATIC_PAD_TEMPLATE ("sink",
  96     GST_PAD_SINK,
  97     GST_PAD_ALWAYS,
  98     GST_STATIC_CAPS_ANY);
  99
 100 #define DEFAULT_UPDATE_FREQ  5
 101 #define DEFAULT_SILENT       FALSE
 102 #define DEFAULT_DO_QUERY     TRUE
 103 #define DEFAULT_FORMAT       "auto"
 104
 105 static void gst_progress_report_set_property (GObject * object, guint prop_id,
 106     const GValue * value, GParamSpec * pspec);
 107 static void gst_progress_report_get_property (GObject * object, guint prop_id,
 108     GValue * value, GParamSpec * pspec);
 109
 110 static gboolean gst_progress_report_sink_event (GstBaseTransform * trans,
 111     GstEvent * event);
 112 static GstFlowReturn gst_progress_report_transform_ip (GstBaseTransform * trans,
 113     GstBuffer * buf);
 114
 115 static gboolean gst_progress_report_start (GstBaseTransform * trans);
 116 static gboolean gst_progress_report_stop (GstBaseTransform * trans);
 117
 118 #define gst_progress_report_parent_class parent_class
 119 G_DEFINE_TYPE (GstProgressReport, gst_progress_report, GST_TYPE_BASE_TRANSFORM);
 120
 121 static void
 122 gst_progress_report_finalize (GObject * obj)
 123 {
 124   GstProgressReport *filter = GST_PROGRESS_REPORT (obj);
 125
 126   g_free (filter->format);
 127   filter->format = NULL;
 128
 129   G_OBJECT_CLASS (parent_class)->finalize (obj);
 130 }
 131
 132 static void
 133 gst_progress_report_class_init (GstProgressReportClass * g_class)
 134 {
 135   GstBaseTransformClass *gstbasetrans_class;
 136   GstElementClass *element_class;
 137   GObjectClass *gobject_class;
 138
 139   gobject_class = G_OBJECT_CLASS (g_class);
 140   element_class = GST_ELEMENT_CLASS (g_class);
 141   gstbasetrans_class = GST_BASE_TRANSFORM_CLASS (g_class);
 142
 143   gobject_class->finalize = gst_progress_report_finalize;
 144   gobject_class->set_property = gst_progress_report_set_property;
 145   gobject_class->get_property = gst_progress_report_get_property;
 146
 147   g_object_class_install_property (gobject_class,
 148       ARG_UPDATE_FREQ, g_param_spec_int ("update-freq", "Update Frequency",
 149           "Number of seconds between reports when data is flowing", 1, G_MAXINT,
 150           DEFAULT_UPDATE_FREQ, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 151
 152   g_object_class_install_property (gobject_class,
 153       ARG_SILENT, g_param_spec_boolean ("silent",
 154           "Do not print output to stdout", "Do not print output to stdout",
 155           DEFAULT_SILENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 156
 157   g_object_class_install_property (gobject_class,
 158       ARG_DO_QUERY, g_param_spec_boolean ("do-query",
 159           "Use a query instead of buffer metadata to determine stream position",
 160           "Use a query instead of buffer metadata to determine stream position",
 161           DEFAULT_DO_QUERY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 162
 163   g_object_class_install_property (gobject_class,
 164       ARG_FORMAT, g_param_spec_string ("format", "format",
 165           "Format to use for the querying", DEFAULT_FORMAT,
 166           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 167
 168   gst_element_class_add_pad_template (element_class,
 169       gst_static_pad_template_get (&progress_report_sink_template));
 170   gst_element_class_add_pad_template (element_class,
 171       gst_static_pad_template_get (&progress_report_src_template));
 172
 173   gst_element_class_set_details_simple (element_class, "Progress report",
 174       "Testing",
 175       "Periodically query and report on processing progress",
 176       "Jan Schmidt <thaytan@mad.scientist.com>");
 177
 178   gstbasetrans_class->sink_event =
 179       GST_DEBUG_FUNCPTR (gst_progress_report_sink_event);
 180   gstbasetrans_class->transform_ip =
 181       GST_DEBUG_FUNCPTR (gst_progress_report_transform_ip);
 182   gstbasetrans_class->start = GST_DEBUG_FUNCPTR (gst_progress_report_start);
 183   gstbasetrans_class->stop = GST_DEBUG_FUNCPTR (gst_progress_report_stop);
 184 }
 185
 186 static void
 187 gst_progress_report_init (GstProgressReport * report)
 188 {
 189   gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (report), TRUE);
 190
 191   report->update_freq = DEFAULT_UPDATE_FREQ;
 192   report->silent = DEFAULT_SILENT;
 193   report->do_query = DEFAULT_DO_QUERY;
 194   report->format = g_strdup (DEFAULT_FORMAT);
 195 }
 196
 197 static void
 198 gst_progress_report_post_progress (GstProgressReport * filter,
 199     GstFormat format, gint64 current, gint64 total)
 200 {
 201   GstStructure *s = NULL;
 202
 203   if (current >= 0 && total > 0) {
 204     gdouble perc;
 205
 206     perc = gst_util_guint64_to_gdouble (current) * 100.0 /
 207         gst_util_guint64_to_gdouble (total);
 208     perc = CLAMP (perc, 0.0, 100.0);
 209
 210     /* we provide a "percent" field of integer type to stay compatible
 211      * with qtdemux, but add a second "percent-double" field for those who
 212      * want more precision and are too lazy to calculate it themselves */
 213     s = gst_structure_new ("progress", "percent", G_TYPE_INT, (gint) perc,
 214         "percent-double", G_TYPE_DOUBLE, perc, "current", G_TYPE_INT64, current,
 215         "total", G_TYPE_INT64, total, NULL);
 216   } else if (current >= 0) {
 217     s = gst_structure_new ("progress", "current", G_TYPE_INT64, current, NULL);
 218   }
 219
 220   if (s) {
 221     GST_LOG_OBJECT (filter, "posting progress message: %" GST_PTR_FORMAT, s);
 222     gst_structure_set (s, "format", GST_TYPE_FORMAT, format, NULL);
 223     /* can't post it right here because we're holding the object lock */
 224     filter->pending_msg = gst_message_new_element (GST_OBJECT_CAST (filter), s);
 225   }
 226 }
 227
 228 static gboolean
 229 gst_progress_report_do_query (GstProgressReport * filter, GstFormat format,
 230     gint hh, gint mm, gint ss, GstBuffer * buf)
 231 {
 232   const gchar *format_name = NULL;
 233   GstPad *sink_pad;
 234   gint64 cur, total;
 235
 236   sink_pad = GST_BASE_TRANSFORM (filter)->sinkpad;
 237
 238   GST_LOG_OBJECT (filter, "querying using format %d (%s)", format,
 239       gst_format_get_name (format));
 240
 241   if (filter->do_query || !buf) {
 242     GST_LOG_OBJECT (filter, "using upstream query");
 243     if (!gst_pad_peer_query_position (sink_pad, format, &cur) ||
 244         !gst_pad_peer_query_duration (sink_pad, format, &total)) {
 245       return FALSE;
 246     }
 247   } else {
 248     GstBaseTransform *base = GST_BASE_TRANSFORM (filter);
 249
 250     GST_LOG_OBJECT (filter, "using buffer metadata");
 251     if (format == GST_FORMAT_TIME && base->segment.format == GST_FORMAT_TIME) {
 252       cur = gst_segment_to_stream_time (&base->segment, format,
 253           GST_BUFFER_TIMESTAMP (buf));
 254       total = base->segment.duration;
 255     } else {
 256       return FALSE;
 257     }
 258   }
 259
 260   switch (format) {
 261     case GST_FORMAT_BYTES:
 262       format_name = "bytes";
 263       break;
 264     case GST_FORMAT_BUFFERS:
 265       format_name = "buffers";
 266       break;
 267     case GST_FORMAT_PERCENT:
 268       format_name = "percent";
 269       break;
 270     case GST_FORMAT_TIME:
 271       format_name = "seconds";
 272       cur /= GST_SECOND;
 273       total /= GST_SECOND;
 274       break;
 275     case GST_FORMAT_DEFAULT:{
 276       GstCaps *caps;
 277
 278       format_name = "bogounits";
 279       caps = gst_pad_get_current_caps (GST_BASE_TRANSFORM (filter)->sinkpad);
 280       if (caps) {
 281         if (gst_caps_is_fixed (caps) && !gst_caps_is_any (caps)) {
 282           GstStructure *s = gst_caps_get_structure (caps, 0);
 283           const gchar *mime_type = gst_structure_get_name (s);
 284
 285           if (g_str_has_prefix (mime_type, "video/") ||
 286               g_str_has_prefix (mime_type, "image/")) {
 287             format_name = "frames";
 288           } else if (g_str_has_prefix (mime_type, "audio/")) {
 289             format_name = "samples";
 290           }
 291         }
 292         gst_caps_unref (caps);
 293       }
 294       break;
 295     }
 296     default:{
 297       const GstFormatDefinition *details;
 298
 299       details = gst_format_get_details (format);
 300       if (details) {
 301         format_name = details->nick;
 302       } else {
 303         format_name = "unknown";
 304       }
 305       break;
 306     }
 307   }
 308
 309   if (!filter->silent) {
 310     if (total > 0) {
 311       g_print ("%s (%02d:%02d:%02d): %" G_GINT64_FORMAT " / %"
 312           G_GINT64_FORMAT " %s (%4.1f %%)\n", GST_OBJECT_NAME (filter), hh,
 313           mm, ss, cur, total, format_name, (gdouble) cur / total * 100.0);
 314     } else {
 315       g_print ("%s (%02d:%02d:%02d): %" G_GINT64_FORMAT " %s\n",
 316           GST_OBJECT_NAME (filter), hh, mm, ss, cur, format_name);
 317     }
 318   }
 319
 320   gst_progress_report_post_progress (filter, format, cur, total);
 321   return TRUE;
 322 }
 323
 324 static void
 325 gst_progress_report_report (GstProgressReport * filter, GTimeVal cur_time,
 326     GstBuffer * buf)
 327 {
 328   GstFormat try_formats[] = { GST_FORMAT_TIME, GST_FORMAT_BYTES,
 329     GST_FORMAT_PERCENT, GST_FORMAT_BUFFERS,
 330     GST_FORMAT_DEFAULT
 331   };
 332   GstMessage *msg;
 333   GstFormat format = GST_FORMAT_UNDEFINED;
 334   gboolean done = FALSE;
 335   glong run_time;
 336   gint hh, mm, ss;
 337
 338   run_time = cur_time.tv_sec - filter->start_time.tv_sec;
 339
 340   hh = (run_time / 3600) % 100;
 341   mm = (run_time / 60) % 60;
 342   ss = (run_time % 60);
 343
 344   GST_OBJECT_LOCK (filter);
 345
 346   if (filter->format != NULL && strcmp (filter->format, "auto") != 0) {
 347     format = gst_format_get_by_nick (filter->format);
 348   }
 349
 350   if (format != GST_FORMAT_UNDEFINED) {
 351     done = gst_progress_report_do_query (filter, format, hh, mm, ss, buf);
 352   } else {
 353     gint i;
 354
 355     for (i = 0; i < G_N_ELEMENTS (try_formats); ++i) {
 356       done = gst_progress_report_do_query (filter, try_formats[i], hh, mm, ss,
 357           buf);
 358       if (done)
 359         break;
 360     }
 361   }
 362
 363   if (!done && !filter->silent) {
 364     g_print ("%s (%2d:%2d:%2d): Could not query position and/or duration\n",
 365         GST_OBJECT_NAME (filter), hh, mm, ss);
 366   }
 367
 368   msg = filter->pending_msg;
 369   filter->pending_msg = NULL;
 370   GST_OBJECT_UNLOCK (filter);
 371
 372   if (msg) {
 373     gst_element_post_message (GST_ELEMENT_CAST (filter), msg);
 374   }
 375 }
 376
 377 static gboolean
 378 gst_progress_report_sink_event (GstBaseTransform * trans, GstEvent * event)
 379 {
 380   GstProgressReport *filter;
 381
 382   filter = GST_PROGRESS_REPORT (trans);
 383
 384   switch (GST_EVENT_TYPE (event)) {
 385     case GST_EVENT_EOS:
 386     {
 387       GTimeVal cur_time;
 388
 389       g_get_current_time (&cur_time);
 390       gst_progress_report_report (filter, cur_time, NULL);
 391       break;
 392     }
 393     default:
 394       break;
 395   }
 396   return GST_BASE_TRANSFORM_CLASS (parent_class)->sink_event (trans, event);
 397 }
 398
 399 static GstFlowReturn
 400 gst_progress_report_transform_ip (GstBaseTransform * trans, GstBuffer * buf)
 401 {
 402   GstProgressReport *filter;
 403   gboolean need_update;
 404   GTimeVal cur_time;
 405
 406   g_get_current_time (&cur_time);
 407
 408   filter = GST_PROGRESS_REPORT (trans);
 409
 410   /* Check if update_freq seconds have passed since the last update */
 411   GST_OBJECT_LOCK (filter);
 412   need_update =
 413       ((cur_time.tv_sec - filter->last_report.tv_sec) >= filter->update_freq);
 414   GST_OBJECT_UNLOCK (filter);
 415
 416   if (need_update) {
 417     gst_progress_report_report (filter, cur_time, buf);
 418     GST_OBJECT_LOCK (filter);
 419     filter->last_report = cur_time;
 420     GST_OBJECT_UNLOCK (filter);
 421   }
 422
 423   return GST_FLOW_OK;
 424 }
 425
 426 static gboolean
 427 gst_progress_report_start (GstBaseTransform * trans)
 428 {
 429   GstProgressReport *filter;
 430
 431   filter = GST_PROGRESS_REPORT (trans);
 432
 433   g_get_current_time (&filter->last_report);
 434   filter->start_time = filter->last_report;
 435
 436   return TRUE;
 437 }
 438
 439 static gboolean
 440 gst_progress_report_stop (GstBaseTransform * trans)
 441 {
 442   /* anything we should be doing here? */
 443   return TRUE;
 444 }
 445
 446 static void
 447 gst_progress_report_set_property (GObject * object, guint prop_id,
 448     const GValue * value, GParamSpec * pspec)
 449 {
 450   GstProgressReport *filter;
 451
 452   filter = GST_PROGRESS_REPORT (object);
 453
 454   switch (prop_id) {
 455     case ARG_UPDATE_FREQ:
 456       GST_OBJECT_LOCK (filter);
 457       filter->update_freq = g_value_get_int (value);
 458       GST_OBJECT_UNLOCK (filter);
 459       break;
 460     case ARG_SILENT:
 461       GST_OBJECT_LOCK (filter);
 462       filter->silent = g_value_get_boolean (value);
 463       GST_OBJECT_UNLOCK (filter);
 464       break;
 465     case ARG_DO_QUERY:
 466       GST_OBJECT_LOCK (filter);
 467       filter->do_query = g_value_get_boolean (value);
 468       GST_OBJECT_UNLOCK (filter);
 469       break;
 470     case ARG_FORMAT:
 471       GST_OBJECT_LOCK (filter);
 472       g_free (filter->format);
 473       filter->format = g_value_dup_string (value);
 474       if (filter->format == NULL)
 475         filter->format = g_strdup ("auto");
 476       GST_OBJECT_UNLOCK (filter);
 477       break;
 478     default:
 479       break;
 480   }
 481 }
 482
 483 static void
 484 gst_progress_report_get_property (GObject * object, guint prop_id,
 485     GValue * value, GParamSpec * pspec)
 486 {
 487   GstProgressReport *filter;
 488
 489   filter = GST_PROGRESS_REPORT (object);
 490
 491   switch (prop_id) {
 492     case ARG_UPDATE_FREQ:
 493       GST_OBJECT_LOCK (filter);
 494       g_value_set_int (value, filter->update_freq);
 495       GST_OBJECT_UNLOCK (filter);
 496       break;
 497     case ARG_SILENT:
 498       GST_OBJECT_LOCK (filter);
 499       g_value_set_boolean (value, filter->silent);
 500       GST_OBJECT_UNLOCK (filter);
 501       break;
 502     case ARG_DO_QUERY:
 503       GST_OBJECT_LOCK (filter);
 504       g_value_set_boolean (value, filter->do_query);
 505       GST_OBJECT_UNLOCK (filter);
 506       break;
 507     case ARG_FORMAT:
 508       GST_OBJECT_LOCK (filter);
 509       g_value_set_string (value, filter->format);
 510       GST_OBJECT_UNLOCK (filter);
 511       break;
 512     default:
 513       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 514       break;
 515   }
 516 }