/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ #include "config.h" #include #include #include #include #include #include #include "shell-recorder-src.h" #include "shell-recorder.h" #include #include typedef enum { RECORDER_STATE_CLOSED, RECORDER_STATE_PAUSED, RECORDER_STATE_RECORDING } RecorderState; typedef struct _RecorderPipeline RecorderPipeline; struct _ShellRecorderClass { GObjectClass parent_class; }; struct _ShellRecorder { GObject parent; /* A "maximum" amount of memory to use for buffering. This is used * to alert the user that they are filling up memory rather than * any that actually affects recording. (In kB) */ guint memory_target; guint memory_used; /* Current memory used. (In kB) */ RecorderState state; char *unique; /* The unique string we are using for this recording */ int count; /* How many times the recording has been started */ ClutterStage *stage; int stage_width; int stage_height; gboolean have_pointer; int pointer_x; int pointer_y; gboolean have_xfixes; int xfixes_event_base; CoglHandle *recording_icon; /* icon shown while playing */ cairo_surface_t *cursor_image; int cursor_hot_x; int cursor_hot_y; gboolean only_paint; /* Used to temporarily suppress recording */ gboolean have_pack_invert; /* True when GL_MESA_pack_invert is available */ int framerate; char *pipeline_description; char *filename; gboolean filename_has_count; /* %c used: handle pausing differently */ /* We might have multiple pipelines that are finishing encoding * to go along with the current pipeline where we are recording. */ RecorderPipeline *current_pipeline; /* current pipeline */ GSList *pipelines; /* all pipelines */ GstClockTime start_time; /* When we started recording (adjusted for pauses) */ GstClockTime pause_time; /* When the pipeline was paused */ /* GSource IDs for different timeouts and idles */ guint redraw_timeout; guint redraw_idle; guint update_memory_used_timeout; guint update_pointer_timeout; }; struct _RecorderPipeline { ShellRecorder *recorder; GstElement *pipeline; GstElement *src; int outfile; }; static void recorder_set_stage (ShellRecorder *recorder, ClutterStage *stage); static void recorder_set_framerate (ShellRecorder *recorder, int framerate); static void recorder_set_pipeline (ShellRecorder *recorder, const char *pipeline); static void recorder_set_filename (ShellRecorder *recorder, const char *filename); static void recorder_pipeline_set_caps (RecorderPipeline *pipeline); static void recorder_pipeline_closed (RecorderPipeline *pipeline); enum { PROP_0, PROP_STAGE, PROP_FRAMERATE, PROP_PIPELINE, PROP_FILENAME }; G_DEFINE_TYPE(ShellRecorder, shell_recorder, G_TYPE_OBJECT); /* The number of frames per second we configure for the GStreamer pipeline. * (the number of frames we actually write into the GStreamer pipeline is * based entirely on how fast clutter is drawing.) Using 60fps seems high * but the observed smoothness is a lot better than for 30fps when encoding * as theora for a minimal size increase. This may be an artifact of the * encoding process. */ #define DEFAULT_FRAMES_PER_SECOND 15 /* The time (in milliseconds) between querying the server for the cursor * position. */ #define UPDATE_POINTER_TIME 100 /* The time we wait (in milliseconds) before redrawing when the memory used * changes. */ #define UPDATE_MEMORY_USED_DELAY 500 /* Maximum time between frames, in milliseconds. If we don't send data * for a long period of time, then when we send the next frame, a lot * of work can be created for the encoder to do, so we want to force a * periodic redraw when nothing happen. */ #define MAXIMUM_PAUSE_TIME 1000 /* The default pipeline. videorate is used to give a constant stream of * frames to theora even if there is a pause because nothing is moving. * (Theora does have some support for frames at non-uniform times, but * things seem to break down if there are large gaps.) */ #define DEFAULT_PIPELINE "videorate ! theoraenc ! oggmux" /* The default filename pattern. Example shell-20090311b-2.ogg */ #define DEFAULT_FILENAME "shell-%d%u-%c.ogg" /* If we can find the amount of memory on the machine, we use half * of that for memory_target, otherwise, we use this value, in kB. */ #define DEFAULT_MEMORY_TARGET (512*1024) /* Create an emblem to show at the lower-left corner of the stage while * recording. The emblem is drawn *after* we record the frame so doesn't * show up in the frame. */ static CoglHandle * create_recording_icon (void) { cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 32, 32); cairo_t *cr; cairo_pattern_t *pat; CoglHandle *texture; cr = cairo_create (surface); /* clear to transparent */ cairo_save (cr); cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); cairo_paint (cr); cairo_restore (cr); /* radial "glow" */ pat = cairo_pattern_create_radial (16, 16, 6, 16, 16, 14); cairo_pattern_add_color_stop_rgba (pat, 0.0, 1, 0, 0, 1); /* opaque red */ cairo_pattern_add_color_stop_rgba (pat, 1.0, 1, 0, 0, 0); /* transparent red */ cairo_set_source (cr, pat); cairo_paint (cr); cairo_pattern_destroy (pat); /* red circle */ cairo_arc (cr, 16, 16, 8, 0, 2 * M_PI); cairo_set_source_rgb (cr, 1, 0, 0); cairo_fill (cr); cairo_destroy (cr); texture = cogl_texture_new_from_data (32, 32, COGL_TEXTURE_NONE, COGL_PIXEL_FORMAT_BGRA_8888, COGL_PIXEL_FORMAT_ANY, cairo_image_surface_get_stride (surface), cairo_image_surface_get_data (surface)); cairo_surface_destroy (surface); return texture; } static guint get_memory_target (void) { FILE *f; /* Really simple "get amount of memory on the machine" if it * doesn't work, you just get the default memory target. */ f = fopen("/proc/meminfo", "r"); if (!f) return DEFAULT_MEMORY_TARGET; while (!feof(f)) { gchar line_buffer[1024]; guint mem_total; if (fscanf(f, "MemTotal: %u", &mem_total) == 1) { fclose(f); return mem_total / 2; } /* Skip to the next line and discard what we read */ if (fgets(line_buffer, sizeof(line_buffer), f) == NULL) break; } fclose(f); return DEFAULT_MEMORY_TARGET; } static void shell_recorder_init (ShellRecorder *recorder) { /* Calling gst_init() is a no-op if GStreamer was previously initialized */ gst_init (NULL, NULL); shell_recorder_src_register (); recorder->recording_icon = create_recording_icon (); recorder->memory_target = get_memory_target(); recorder->state = RECORDER_STATE_CLOSED; recorder->framerate = DEFAULT_FRAMES_PER_SECOND; } static void shell_recorder_finalize (GObject *object) { ShellRecorder *recorder = SHELL_RECORDER (object); GSList *l; for (l = recorder->pipelines; l; l = l->next) { RecorderPipeline *pipeline = l->data; /* Remove the back-reference. The pipeline will be freed * when it finishes. (Or when the process exits, but that's * out of our control.) */ pipeline->recorder = NULL; } if (recorder->update_memory_used_timeout) g_source_remove (recorder->update_memory_used_timeout); if (recorder->cursor_image) cairo_surface_destroy (recorder->cursor_image); recorder_set_stage (recorder, NULL); recorder_set_pipeline (recorder, NULL); recorder_set_filename (recorder, NULL); cogl_handle_unref (recorder->recording_icon); G_OBJECT_CLASS (shell_recorder_parent_class)->finalize (object); } static void recorder_on_stage_destroy (ClutterActor *actor, ShellRecorder *recorder) { recorder_set_stage (recorder, NULL); } /* Add together the memory used by all pipelines; both the * currently recording pipeline and pipelines finishing * recording asynchronously. */ static void recorder_update_memory_used (ShellRecorder *recorder, gboolean repaint) { guint memory_used = 0; GSList *l; for (l = recorder->pipelines; l; l = l->next) { RecorderPipeline *pipeline = l->data; guint pipeline_memory_used; g_object_get (pipeline->src, "memory-used", &pipeline_memory_used, NULL); memory_used += pipeline_memory_used; } if (memory_used != recorder->memory_used) { recorder->memory_used = memory_used; if (repaint) { /* In other cases we just queue a redraw even if we only need * to repaint and not redraw a frame, but having changes in * memory usage cause frames to be painted and memory used * seems like a bad idea. */ recorder->only_paint = TRUE; clutter_redraw (recorder->stage); recorder->only_paint = FALSE; } } } /* Timeout used to avoid not drawing for more than MAXIMUM_PAUSE_TIME */ static gboolean recorder_redraw_timeout (gpointer data) { ShellRecorder *recorder = data; recorder->redraw_timeout = 0; clutter_actor_queue_redraw (CLUTTER_ACTOR (recorder->stage)); return FALSE; } static void recorder_add_redraw_timeout (ShellRecorder *recorder) { if (recorder->redraw_timeout == 0) { recorder->redraw_timeout = g_timeout_add (MAXIMUM_PAUSE_TIME, recorder_redraw_timeout, recorder); } } static void recorder_remove_redraw_timeout (ShellRecorder *recorder) { if (recorder->redraw_timeout != 0) { g_source_remove (recorder->redraw_timeout); recorder->redraw_timeout = 0; } } static void recorder_fetch_cursor_image (ShellRecorder *recorder) { XFixesCursorImage *cursor_image; guchar *data; int stride; int i, j; if (!recorder->have_xfixes) return; cursor_image = XFixesGetCursorImage (clutter_x11_get_default_display ()); recorder->cursor_hot_x = cursor_image->xhot; recorder->cursor_hot_y = cursor_image->yhot; recorder->cursor_image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, cursor_image->width, cursor_image->height); /* The pixel data (in typical Xlib breakage) is longs even on * 64-bit platforms, so we have to data-convert there. For simplicity, * just do it always */ data = cairo_image_surface_get_data (recorder->cursor_image); stride = cairo_image_surface_get_stride (recorder->cursor_image); for (i = 0; i < cursor_image->height; i++) for (j = 0; j < cursor_image->width; j++) *(guint32 *)(data + i * stride + 4 * j) = cursor_image->pixels[i * cursor_image->width + j]; } /* Overlay the cursor image on the frame. We draw the cursor image * into the host-memory buffer after we've captured the frame. An * alternate approach would be to turn off the cursor while recording * and draw the cursor ourselves with GL, but then we'd need to figure * out what the cursor looks like, or hard-code a non-system cursor. */ static void recorder_draw_cursor (ShellRecorder *recorder, GstBuffer *buffer) { cairo_surface_t *surface; cairo_t *cr; /* We don't show a cursor unless the hot spot is in the frame; this * means that sometimes we aren't going to draw a cursor even when * there is a little bit overlapping within the stage */ if (recorder->pointer_x < 0 || recorder->pointer_y < 0 || recorder->pointer_x >= recorder->stage_width || recorder->pointer_y >= recorder->stage_height) return; if (!recorder->cursor_image) recorder_fetch_cursor_image (recorder); if (!recorder->cursor_image) return; surface = cairo_image_surface_create_for_data (GST_BUFFER_DATA(buffer), CAIRO_FORMAT_ARGB32, recorder->stage_width, recorder->stage_height, recorder->stage_width * 4); /* When not using GL_MESA_pack_invert the data we get from glReadPixels is "upside down", * so transform our cairo drawing to match */ cr = cairo_create (surface); if (!recorder->have_pack_invert) { cairo_translate(cr, 0, recorder->stage_height); cairo_scale(cr, 1, -1); } cairo_set_source_surface (cr, recorder->cursor_image, recorder->pointer_x - recorder->cursor_hot_x, recorder->pointer_y - recorder->cursor_hot_y); cairo_paint (cr); cairo_destroy (cr); cairo_surface_destroy (surface); } /* Draw an overlay indicating how much of the target memory is used * for buffering frames. */ static void recorder_draw_buffer_meter (ShellRecorder *recorder) { int fill_level; recorder_update_memory_used (recorder, FALSE); /* As the buffer gets more full, we go from green, to yellow, to red */ if (recorder->memory_used > (recorder->memory_target * 3) / 4) cogl_set_source_color4f (1, 0, 0, 1); else if (recorder->memory_used > recorder->memory_target / 2) cogl_set_source_color4f (1, 1, 0, 1); else cogl_set_source_color4f (0, 1, 0, 1); fill_level = MIN (60, (recorder->memory_used * 60) / recorder->memory_target); /* A hollow rectangle filled from the left to fill_level */ cogl_rectangle (recorder->stage_width - 64, recorder->stage_height - 10, recorder->stage_width - 2, recorder->stage_height - 9); cogl_rectangle (recorder->stage_width - 64, recorder->stage_height - 9, recorder->stage_width - (63 - fill_level), recorder->stage_height - 3); cogl_rectangle (recorder->stage_width - 3, recorder->stage_height - 9, recorder->stage_width - 2, recorder->stage_height - 3); cogl_rectangle (recorder->stage_width - 64, recorder->stage_height - 3, recorder->stage_width - 2, recorder->stage_height - 2); } /* We want to time-stamp each frame based on the actual time it was * recorded. We probably should use the pipeline clock rather than * gettimeofday(): that would be needed to get sync'ed audio correct. * I'm not immediately sure how to handle the adjustment we currently * do when pausing recording - is pausing the pipeline enough? */ static GstClockTime get_wall_time (void) { GTimeVal tv; g_get_current_time (&tv); return tv.tv_sec * 1000000000LL + tv.tv_usec * 1000LL; } /* Retrieve a frame and feed it into the pipeline */ static void recorder_record_frame (ShellRecorder *recorder) { GstBuffer *buffer; guint8 *data; guint size; size = recorder->stage_width * recorder->stage_height * 4; data = g_malloc (size); buffer = gst_buffer_new(); GST_BUFFER_SIZE(buffer) = size; GST_BUFFER_MALLOCDATA(buffer) = GST_BUFFER_DATA(buffer) = data; GST_BUFFER_TIMESTAMP(buffer) = get_wall_time() - recorder->start_time; /* We could use cogl_read_pixels, but it only currently supports * COGL_PIXEL_FORMAT_RGBA_8888, while we prefer the native framebuffer * format. (COGL_PIXEL_FORMAT_ARGB_8888_PRE, * COGL_PIXEL_FORMAT_BGRA_PRE, depending on endianess) * * http://bugzilla.openedhand.com/show_bug.cgi?id=1959 */ /* Flush any primitives that Cogl has batched up */ cogl_flush (); /* Set the parameters for how data is stored; these are the initial * values but Cogl will have modified them for its own purposes */ glPixelStorei (GL_PACK_ALIGNMENT, 4); glPixelStorei (GL_PACK_ROW_LENGTH, 0); glPixelStorei (GL_PACK_SKIP_PIXELS, 0); glPixelStorei (GL_PACK_SKIP_ROWS, 0); if (recorder->have_pack_invert) glPixelStorei (GL_PACK_INVERT_MESA, TRUE); glReadBuffer (GL_BACK_LEFT); glReadPixels (0, 0, recorder->stage_width, recorder->stage_height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data); if (recorder->have_pack_invert) glPixelStorei (GL_PACK_INVERT_MESA, FALSE); recorder_draw_cursor (recorder, buffer); shell_recorder_src_add_buffer (SHELL_RECORDER_SRC (recorder->current_pipeline->src), buffer); gst_buffer_unref (buffer); /* Reset the timeout that we used to avoid an overlong pause in the stream */ recorder_remove_redraw_timeout (recorder); recorder_add_redraw_timeout (recorder); } /* We hook in by recording each frame right after the stage is painted * by clutter before glSwapBuffers() makes it visible to the user. */ static void recorder_on_stage_paint (ClutterActor *actor, ShellRecorder *recorder) { if (recorder->state == RECORDER_STATE_RECORDING) { if (!recorder->only_paint) recorder_record_frame (recorder); cogl_set_source_texture (recorder->recording_icon); cogl_rectangle (recorder->stage_width - 32, recorder->stage_height - 42, recorder->stage_width, recorder->stage_height - 10); } if (recorder->state == RECORDER_STATE_RECORDING || recorder->memory_used != 0) recorder_draw_buffer_meter (recorder); } static void recorder_update_size (ShellRecorder *recorder) { ClutterActorBox allocation; clutter_actor_get_allocation_box (CLUTTER_ACTOR (recorder->stage), &allocation); recorder->stage_width = (int)(0.5 + allocation.x2 - allocation.x1); recorder->stage_height = (int)(0.5 + allocation.y2 - allocation.y1); } static void recorder_on_stage_notify_size (GObject *object, GParamSpec *pspec, ShellRecorder *recorder) { recorder_update_size (recorder); /* This breaks the recording but tweaking the GStreamer pipeline a bit * might make it work, at least if the codec can handle a stream where * the frame size changes in the middle. */ if (recorder->current_pipeline) recorder_pipeline_set_caps (recorder->current_pipeline); } static gboolean recorder_idle_redraw (gpointer data) { ShellRecorder *recorder = data; recorder->redraw_idle = 0; clutter_actor_queue_redraw (CLUTTER_ACTOR (recorder->stage)); return FALSE; } static void recorder_queue_redraw (ShellRecorder *recorder) { /* If we just queue a redraw on every mouse motion (for example), we * starve Clutter, which operates at a very low priority. So * we need to queue a "low priority redraw" after timeline updates */ if (recorder->state == RECORDER_STATE_RECORDING && recorder->redraw_idle == 0) recorder->redraw_idle = g_idle_add_full (CLUTTER_PRIORITY_REDRAW + 1, recorder_idle_redraw, recorder, NULL); } /* We use an event filter on the stage to get the XFixesCursorNotifyEvent * and also to track cursor position (when the cursor is over the stage's * input area); tracking cursor position here rather than with ClutterEvent * allows us to avoid worrying about event propagation and competing * signal handlers. */ static ClutterX11FilterReturn recorder_event_filter (XEvent *xev, ClutterEvent *cev, gpointer data) { ShellRecorder *recorder = data; if (xev->xany.window != clutter_x11_get_stage_window (recorder->stage)) return CLUTTER_X11_FILTER_CONTINUE; if (xev->xany.type == recorder->xfixes_event_base + XFixesCursorNotify) { XFixesCursorNotifyEvent *notify_event = (XFixesCursorNotifyEvent *)xev; if (notify_event->subtype == XFixesDisplayCursorNotify) { if (recorder->cursor_image) { cairo_surface_destroy (recorder->cursor_image); recorder->cursor_image = NULL; } recorder_queue_redraw (recorder); } } else if (xev->xany.type == MotionNotify) { recorder->pointer_x = xev->xmotion.x; recorder->pointer_y = xev->xmotion.y; recorder_queue_redraw (recorder); } /* We want to track whether the pointer is over the stage * window itself, and not in a child window. A "virtual" * crossing is one that goes directly from ancestor to child. */ else if (xev->xany.type == EnterNotify && (xev->xcrossing.detail != NotifyVirtual && xev->xcrossing.detail != NotifyNonlinearVirtual)) { recorder->have_pointer = TRUE; recorder->pointer_x = xev->xcrossing.x; recorder->pointer_y = xev->xcrossing.y; recorder_queue_redraw (recorder); } else if (xev->xany.type == LeaveNotify && (xev->xcrossing.detail != NotifyVirtual && xev->xcrossing.detail != NotifyNonlinearVirtual)) { recorder->have_pointer = FALSE; recorder->pointer_x = xev->xcrossing.x; recorder->pointer_y = xev->xcrossing.y; recorder_queue_redraw (recorder); } return CLUTTER_X11_FILTER_CONTINUE; } /* We optimize out querying the server for the pointer position if the * pointer is in the input area of the ClutterStage. We track changes to * that with Enter/Leave events, but we need to 100% accurate about the * initial condition, which is a little involved. */ static void recorder_get_initial_cursor_position (ShellRecorder *recorder) { Display *xdisplay = clutter_x11_get_default_display (); Window xwindow = clutter_x11_get_stage_window (recorder->stage); XWindowAttributes xwa; Window root, child, parent; Window *children; guint n_children; int root_x,root_y; int window_x, window_y; guint mask; XGrabServer(xdisplay); XGetWindowAttributes (xdisplay, xwindow, &xwa); XQueryTree (xdisplay, xwindow, &root, &parent, &children, &n_children); XFree (children); if (xwa.map_state == IsViewable && XQueryPointer (xdisplay, parent, &root, &child, &root_x, &root_y, &window_x, &window_y, &mask) && child == xwindow) { /* The point of this call is not actually to translate the coordinates - * we could do that ourselves using xwa.{x,y} - but rather to see if * the pointer is in a child of the window, which we count as "not in * window", because we aren't guaranteed to get pointer events. */ XTranslateCoordinates(xdisplay, parent, xwindow, window_x, window_y, &window_x, &window_y, &child); if (child == None) { recorder->have_pointer = TRUE; recorder->pointer_x = window_x; recorder->pointer_y = window_y; } } else recorder->have_pointer = FALSE; XUngrabServer(xdisplay); XFlush(xdisplay); /* While we are at it, add mouse events to the event mask; they will * be there for the stage windows that Clutter creates by default, but * maybe this stage was created differently. Since we've already * retrieved the event mask, it's almost free. */ XSelectInput(xdisplay, xwindow, xwa.your_event_mask | EnterWindowMask | LeaveWindowMask | PointerMotionMask); } /* When the cursor is not over the stage's input area, we query for the * pointer position in a timeout. */ static void recorder_update_pointer (ShellRecorder *recorder) { Display *xdisplay = clutter_x11_get_default_display (); Window xwindow = clutter_x11_get_stage_window (recorder->stage); Window root, child; int root_x,root_y; int window_x, window_y; guint mask; if (recorder->have_pointer) return; if (XQueryPointer (xdisplay, xwindow, &root, &child, &root_x, &root_y, &window_x, &window_y, &mask)) { if (window_x != recorder->pointer_x || window_y != recorder->pointer_y) { recorder->pointer_x = window_x; recorder->pointer_y = window_y; recorder_queue_redraw (recorder); } } } static gboolean recorder_update_pointer_timeout (gpointer data) { recorder_update_pointer (data); return TRUE; } static void recorder_add_update_pointer_timeout (ShellRecorder *recorder) { if (!recorder->update_pointer_timeout) recorder->update_pointer_timeout = g_timeout_add (UPDATE_POINTER_TIME, recorder_update_pointer_timeout, recorder); } static void recorder_remove_update_pointer_timeout (ShellRecorder *recorder) { if (recorder->update_pointer_timeout) { g_source_remove (recorder->update_pointer_timeout); recorder->update_pointer_timeout = 0; } } static void recorder_set_stage (ShellRecorder *recorder, ClutterStage *stage) { if (recorder->stage == stage) return; if (recorder->current_pipeline) shell_recorder_close (recorder); if (recorder->stage) { g_signal_handlers_disconnect_by_func (recorder->stage, (void *)recorder_on_stage_destroy, recorder); g_signal_handlers_disconnect_by_func (recorder->stage, (void *)recorder_on_stage_paint, recorder); g_signal_handlers_disconnect_by_func (recorder->stage, (void *)recorder_on_stage_notify_size, recorder); clutter_x11_remove_filter (recorder_event_filter, recorder); /* We don't don't deselect for cursor changes in case someone else just * happened to be selecting for cursor events on the same window; sending * us the events is close to free in any case. */ if (recorder->redraw_idle) { g_source_remove (recorder->redraw_idle); recorder->redraw_idle = 0; } } recorder->stage = stage; if (recorder->stage) { int error_base; const char *gl_extensions; recorder->stage = stage; g_signal_connect (recorder->stage, "destroy", G_CALLBACK (recorder_on_stage_destroy), recorder); g_signal_connect_after (recorder->stage, "paint", G_CALLBACK (recorder_on_stage_paint), recorder); g_signal_connect (recorder->stage, "notify::width", G_CALLBACK (recorder_on_stage_notify_size), recorder); g_signal_connect (recorder->stage, "notify::width", G_CALLBACK (recorder_on_stage_notify_size), recorder); clutter_x11_add_filter (recorder_event_filter, recorder); recorder_update_size (recorder); recorder->have_xfixes = XFixesQueryExtension (clutter_x11_get_default_display (), &recorder->xfixes_event_base, &error_base); if (recorder->have_xfixes) XFixesSelectCursorInput (clutter_x11_get_default_display (), clutter_x11_get_stage_window (stage), XFixesDisplayCursorNotifyMask); clutter_stage_ensure_current (stage); gl_extensions = (const char *)glGetString (GL_EXTENSIONS); recorder->have_pack_invert = strstr (gl_extensions, "GL_MESA_pack_invert") != NULL; recorder_get_initial_cursor_position (recorder); } } static void recorder_set_framerate (ShellRecorder *recorder, int framerate) { if (framerate == recorder->framerate) return; if (recorder->current_pipeline) shell_recorder_close (recorder); recorder->framerate = framerate; g_object_notify (G_OBJECT (recorder), "framerate"); } static void recorder_set_pipeline (ShellRecorder *recorder, const char *pipeline) { if (pipeline == recorder->pipeline_description || (pipeline && recorder->pipeline_description && strcmp (recorder->pipeline_description, pipeline) == 0)) return; if (recorder->current_pipeline) shell_recorder_close (recorder); if (recorder->pipeline_description) g_free (recorder->pipeline_description); recorder->pipeline_description = g_strdup (pipeline); g_object_notify (G_OBJECT (recorder), "pipeline"); } static void recorder_set_filename (ShellRecorder *recorder, const char *filename) { if (filename == recorder->filename || (filename && recorder->filename && strcmp (recorder->filename, filename) == 0)) return; if (recorder->current_pipeline) shell_recorder_close (recorder); if (recorder->filename) g_free (recorder->filename); recorder->filename = g_strdup (filename); g_object_notify (G_OBJECT (recorder), "filename"); } static void shell_recorder_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { ShellRecorder *recorder = SHELL_RECORDER (object); switch (prop_id) { case PROP_STAGE: recorder_set_stage (recorder, g_value_get_object (value)); break; case PROP_FRAMERATE: recorder_set_framerate (recorder, g_value_get_int (value)); break; case PROP_PIPELINE: recorder_set_pipeline (recorder, g_value_get_string (value)); break; case PROP_FILENAME: recorder_set_filename (recorder, g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void shell_recorder_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { ShellRecorder *recorder = SHELL_RECORDER (object); switch (prop_id) { case PROP_STAGE: g_value_set_object (value, G_OBJECT (recorder->stage)); break; case PROP_FRAMERATE: g_value_set_int (value, recorder->framerate); break; case PROP_PIPELINE: g_value_set_string (value, recorder->pipeline_description); break; case PROP_FILENAME: g_value_set_string (value, recorder->filename); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void shell_recorder_class_init (ShellRecorderClass *klass) { GObjectClass *gobject_class = G_OBJECT_CLASS (klass); gobject_class->finalize = shell_recorder_finalize; gobject_class->get_property = shell_recorder_get_property; gobject_class->set_property = shell_recorder_set_property; g_object_class_install_property (gobject_class, PROP_STAGE, g_param_spec_object ("stage", "Stage", "Stage to record", CLUTTER_TYPE_STAGE, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_FRAMERATE, g_param_spec_int ("framerate", "Framerate", "Framerate used for resulting video in frames-per-second", 0, G_MAXINT, DEFAULT_FRAMES_PER_SECOND, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_PIPELINE, g_param_spec_string ("pipeline", "Pipeline", "GStreamer pipeline description to encode recordings", NULL, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_FILENAME, g_param_spec_string ("filename", "Filename", "The filename template to use for output files", NULL, G_PARAM_READWRITE)); } /* Sets the GstCaps (video format, in this case) on the stream */ static void recorder_pipeline_set_caps (RecorderPipeline *pipeline) { GstCaps *caps; /* The data is always native-endian xRGB; ffmpegcolorspace * doesn't support little-endian xRGB, but does support * big-endian BGRx. */ caps = gst_caps_new_simple ("video/x-raw-rgb", "bpp", G_TYPE_INT, 32, "depth", G_TYPE_INT, 24, #if G_BYTE_ORDER == G_LITTLE_ENDIAN "red_mask", G_TYPE_INT, 0x0000ff00, "green_mask", G_TYPE_INT, 0x00ff0000, "blue_mask", G_TYPE_INT, 0xff000000, #else "red_mask", G_TYPE_INT, 0xff0000, "green_mask", G_TYPE_INT, 0x00ff00, "blue_mask", G_TYPE_INT, 0x0000ff, #endif "endianness", G_TYPE_INT, G_BIG_ENDIAN, "framerate", GST_TYPE_FRACTION, pipeline->recorder->framerate, 1, "width", G_TYPE_INT, pipeline->recorder->stage_width, "height", G_TYPE_INT, pipeline->recorder->stage_height, NULL); g_object_set (pipeline->src, "caps", caps, NULL); gst_caps_unref (caps); } /* Augments the supplied pipeline with the source elements: the actual * ShellRecorderSrc element where we inject frames then additional elements * to convert the output into something palatable. */ static gboolean recorder_pipeline_add_source (RecorderPipeline *pipeline) { GstPad *sink_pad = NULL, *src_pad = NULL; gboolean result = FALSE; GstElement *ffmpegcolorspace; GstElement *videoflip; GError *error = NULL; sink_pad = gst_bin_find_unlinked_pad (GST_BIN (pipeline->pipeline), GST_PAD_SINK); if (sink_pad == NULL) { g_warning("ShellRecorder: pipeline has no unlinked sink pad"); goto out; } pipeline->src = gst_element_factory_make ("shellrecordersrc", NULL); if (pipeline->src == NULL) { g_warning ("Can't create recorder source element"); goto out; } gst_bin_add (GST_BIN (pipeline->pipeline), pipeline->src); recorder_pipeline_set_caps (pipeline); /* The ffmpegcolorspace element is a generic converter; it will convert * our supplied fixed format data into whatever the encoder wants */ ffmpegcolorspace = gst_element_factory_make ("ffmpegcolorspace", NULL); if (!ffmpegcolorspace) { g_warning("Can't create ffmpegcolorspace element"); goto out; } gst_bin_add (GST_BIN (pipeline->pipeline), ffmpegcolorspace); /* glReadPixels gives us an upside-down buffer, so we have to flip it back * right-side up. * * When available MESA_pack_invert extension is used to avoid the * flip entirely, since the data is actually stored in the frame buffer * in the order that we expect. * * We use gst_parse_launch to avoid having to know the enum value for flip-vertical */ if (!pipeline->recorder->have_pack_invert) { videoflip = gst_parse_launch_full ("videoflip method=vertical-flip", NULL, GST_PARSE_FLAG_FATAL_ERRORS, &error); if (videoflip == NULL) { g_warning("Can't create videoflip element: %s", error->message); g_error_free (error); goto out; } gst_bin_add (GST_BIN (pipeline->pipeline), videoflip); gst_element_link_many (pipeline->src, ffmpegcolorspace, videoflip, NULL); src_pad = gst_element_get_static_pad (videoflip, "src"); } else { gst_element_link_many (pipeline->src, ffmpegcolorspace, NULL); src_pad = gst_element_get_static_pad (ffmpegcolorspace, "src"); } if (!src_pad) { g_warning("ShellRecorder: can't get src pad to link into pipeline"); goto out; } if (gst_pad_link (src_pad, sink_pad) != GST_PAD_LINK_OK) { g_warning("ShellRecorder: can't link to sink pad"); goto out; } result = TRUE; out: if (sink_pad) gst_object_unref (sink_pad); if (src_pad) gst_object_unref (src_pad); return result; } /* Counts '', 'a', ..., 'z', 'aa', ..., 'az', 'ba', ... */ static void increment_unique (GString *unique) { int i; for (i = unique->len - 1; i >= 0; i--) { if (unique->str[i] != 'z') { unique->str[i]++; return; } else unique->str[i] = 'a'; } g_string_prepend_c (unique, 'a'); } static char * get_absolute_path (char *maybe_relative) { char *path; if (g_path_is_absolute (maybe_relative)) path = g_strdup (maybe_relative); else { char *cwd = g_get_current_dir (); path = g_build_filename (cwd, maybe_relative, NULL); g_free (cwd); } return path; } /* Open a file for writing. Opening the file ourselves and using fdsink has * the advantage over filesink of being able to use O_EXCL when we want to * avoid overwriting* an existing file. Returns -1 if the file couldn't * be opened. */ static int recorder_open_outfile (ShellRecorder *recorder) { GString *unique = g_string_new (NULL); /* add to filename to make it unique */ const char *pattern; int flags; int outfile = -1; recorder->count++; pattern = recorder->filename; if (!pattern) pattern = DEFAULT_FILENAME; while (TRUE) { GString *filename = g_string_new (NULL); const char *p; for (p = pattern; *p; p++) { if (*p == '%') { switch (*(p + 1)) { case '%': case '\0': g_string_append_c (filename, '%'); break; case 'c': { /* Count distinguishing multiple files created in session */ g_string_append_printf (filename, "%d", recorder->count); recorder->filename_has_count = TRUE; } break; case 'd': { /* Appends date as YYYYMMDD */ GDate date; GTimeVal now; g_get_current_time (&now); g_date_clear (&date, 1); g_date_set_time_val (&date, &now); g_string_append_printf (filename, "%04d%02d%02d", g_date_get_year (&date), g_date_get_month (&date), g_date_get_day (&date)); } break; case 'u': if (recorder->unique) g_string_append (filename, recorder->unique); else g_string_append (filename, unique->str); break; default: g_warning ("Unknown escape %%%c in filename", *p); goto out; } p++; } else g_string_append_c (filename, *p); } /* If a filename is explicitly specified without %u then we assume the user * is fine with over-writing the old contents; putting %u in the default * should avoid problems with malicious symlinks. */ flags = O_WRONLY | O_CREAT | O_TRUNC; if (recorder->filename_has_count) flags |= O_EXCL; outfile = open (filename->str, flags, 0666); if (outfile != -1) { char *path = get_absolute_path (filename->str); g_printerr ("Recording to %s\n", path); g_free (path); g_string_free (filename, TRUE); goto out; } if (outfile == -1 && (errno != EEXIST || !recorder->filename_has_count)) { g_warning ("Cannot open output file '%s': %s", filename->str, g_strerror (errno)); g_string_free (filename, TRUE); goto out; } if (recorder->unique) { /* We've already picked a unique string based on count=1, and now we had a collision * for a subsequent count. */ g_warning ("Name collision with existing file for '%s'", filename->str); g_string_free (filename, TRUE); goto out; } g_string_free (filename, TRUE); increment_unique (unique); } out: if (outfile != -1) recorder->unique = g_string_free (unique, FALSE); else g_string_free (unique, TRUE); return outfile; } /* Augments the supplied pipeline with a sink element to write to the output * file, if necessary. */ static gboolean recorder_pipeline_add_sink (RecorderPipeline *pipeline) { GstPad *sink_pad = NULL, *src_pad = NULL; GstElement *fdsink; gboolean result = FALSE; src_pad = gst_bin_find_unlinked_pad (GST_BIN (pipeline->pipeline), GST_PAD_SRC); if (src_pad == NULL) { /* Nothing to do - assume that we were given a complete pipeline */ return TRUE; } pipeline->outfile = recorder_open_outfile (pipeline->recorder); if (pipeline->outfile == -1) goto out; fdsink = gst_element_factory_make ("fdsink", NULL); if (fdsink == NULL) { g_warning("Can't create fdsink element"); goto out; } gst_bin_add (GST_BIN (pipeline->pipeline), fdsink); g_object_set (fdsink, "fd", pipeline->outfile, NULL); sink_pad = gst_element_get_static_pad (fdsink, "sink"); if (!sink_pad) { g_warning("ShellRecorder: can't get sink pad to link pipeline output"); goto out; } if (gst_pad_link (src_pad, sink_pad) != GST_PAD_LINK_OK) { g_warning("ShellRecorder: can't link to sink pad"); goto out; } result = TRUE; out: if (src_pad) gst_object_unref (src_pad); if (sink_pad) gst_object_unref (sink_pad); return result; } static gboolean recorder_update_memory_used_timeout (gpointer data) { ShellRecorder *recorder = data; recorder->update_memory_used_timeout = 0; recorder_update_memory_used (recorder, TRUE); return FALSE; } /* We throttle down the frequency which we recompute memory usage * and draw the buffer indicator to avoid cutting into performance. */ static void recorder_pipeline_on_memory_used_changed (ShellRecorderSrc *src, GParamSpec *spec, RecorderPipeline *pipeline) { ShellRecorder *recorder = pipeline->recorder; if (!recorder) return; if (recorder->update_memory_used_timeout == 0) recorder->update_memory_used_timeout = g_timeout_add (UPDATE_MEMORY_USED_DELAY, recorder_update_memory_used_timeout, recorder); } static void recorder_pipeline_free (RecorderPipeline *pipeline) { if (pipeline->pipeline != NULL) gst_object_unref (pipeline->pipeline); if (pipeline->outfile != -1) close (pipeline->outfile); g_free (pipeline); } /* Function gets called on pipeline-global events; we use it to * know when the pipeline is finished. */ static gboolean recorder_pipeline_bus_watch (GstBus *bus, GstMessage *message, gpointer data) { RecorderPipeline *pipeline = data; switch (message->type) { case GST_MESSAGE_EOS: recorder_pipeline_closed (pipeline); return FALSE; /* remove watch */ case GST_MESSAGE_ERROR: { GError *error; gst_message_parse_error (message, &error, NULL); g_warning ("Error in recording pipeline: %s\n", error->message); g_error_free (error); recorder_pipeline_closed (pipeline); return FALSE; /* remove watch */ } default: break; } /* Leave the watch in place */ return TRUE; } /* Clean up when the pipeline is finished */ static void recorder_pipeline_closed (RecorderPipeline *pipeline) { g_signal_handlers_disconnect_by_func (pipeline->src, (gpointer) recorder_pipeline_on_memory_used_changed, pipeline); gst_element_set_state (pipeline->pipeline, GST_STATE_NULL); if (pipeline->recorder) { ShellRecorder *recorder = pipeline->recorder; if (pipeline == recorder->current_pipeline) { /* Error case; force a close */ recorder->current_pipeline = NULL; shell_recorder_close (recorder); } recorder->pipelines = g_slist_remove (recorder->pipelines, pipeline); } recorder_pipeline_free (pipeline); } static gboolean recorder_open_pipeline (ShellRecorder *recorder) { RecorderPipeline *pipeline; const char *pipeline_description; GError *error = NULL; GstBus *bus; pipeline = g_new0(RecorderPipeline, 1); pipeline->recorder = recorder; pipeline->outfile = - 1; pipeline_description = recorder->pipeline_description; if (!pipeline_description) pipeline_description = DEFAULT_PIPELINE; pipeline->pipeline = gst_parse_launch_full (pipeline_description, NULL, GST_PARSE_FLAG_FATAL_ERRORS, &error); if (pipeline->pipeline == NULL) { g_warning ("ShellRecorder: failed to parse pipeline: %s", error->message); g_error_free (error); goto error; } if (!recorder_pipeline_add_source (pipeline)) goto error; if (!recorder_pipeline_add_sink (pipeline)) goto error; gst_element_set_state (pipeline->pipeline, GST_STATE_PLAYING); bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline->pipeline)); gst_bus_add_watch (bus, recorder_pipeline_bus_watch, pipeline); gst_object_unref (bus); g_signal_connect (pipeline->src, "notify::memory-used", G_CALLBACK (recorder_pipeline_on_memory_used_changed), pipeline); recorder->current_pipeline = pipeline; recorder->pipelines = g_slist_prepend (recorder->pipelines, pipeline); return TRUE; error: recorder_pipeline_free (pipeline); return FALSE; } static void recorder_close_pipeline (ShellRecorder *recorder) { if (recorder->current_pipeline != NULL) { /* This will send an EOS (end-of-stream) message after the last frame * is written. The bus watch for the pipeline will get it and do * final cleanup */ shell_recorder_src_close (SHELL_RECORDER_SRC (recorder->current_pipeline->src)); recorder->current_pipeline = NULL; recorder->filename_has_count = FALSE; } } /** * shell_recorder_new: * @stage: The #ClutterStage * * Create a new #ShellRecorder to record movies of a #ClutterStage * * Return value: The newly created #ShellRecorder object */ ShellRecorder * shell_recorder_new (ClutterStage *stage) { return g_object_new (SHELL_TYPE_RECORDER, "stage", stage, NULL); } /** * shell_recorder_set_framerate: * @recorder: the #ShellRecorder * @framerate: Framerate used for resulting video in frames-per-second. * * Sets the number of frames per second we configure for the GStreamer pipeline. * * The default value is 15. */ void shell_recorder_set_framerate (ShellRecorder *recorder, int framerate) { g_return_if_fail (SHELL_IS_RECORDER (recorder)); recorder_set_framerate (recorder, framerate); } /** * shell_recorder_set_filename: * @recorder: the #ShellRecorder * @filename: the filename template to use for output files, * or %NULL for the defalt value. * * Sets the filename that will be used when creating output * files. This is only used if the configured pipeline has an * unconnected source pad (as the default pipeline does). If * the pipeline is complete, then the filename is unused. The * provided string is used as a template.It can contain * the following escapes: * * %d: The current date as YYYYYMMDD * %u: A string added to make the filename unique. * '', 'a', 'b', ... 'aa', 'ab', .. * %c: A counter that is updated (opening a new file) each * time the recording stream is paused. * %%: A literal percent * * The default value is 'shell-%d%u-%c.ogg'. */ void shell_recorder_set_filename (ShellRecorder *recorder, const char *filename) { g_return_if_fail (SHELL_IS_RECORDER (recorder)); recorder_set_filename (recorder, filename); } /** * shell_recorder_set_pipeline: * @recorder: the #ShellRecorder * @pipeline: (allow-none): the GStreamer pipeline used to encode recordings * or %NULL for the default value. * * Sets the GStreamer pipeline used to encode recordings. * It follows the syntax used for gst-launch. The pipeline * should have an unconnected sink pad where the recorded * video is recorded. It will normally have a unconnected * source pad; output from that pad will be written into the * output file. (See shell_recorder_set_filename().) However * the pipeline can also take care of its own output - this * might be used to send the output to an icecast server * via shout2send or similar. * * The default value is 'videorate ! theoraenc ! oggmux' */ void shell_recorder_set_pipeline (ShellRecorder *recorder, const char *pipeline) { g_return_if_fail (SHELL_IS_RECORDER (recorder)); recorder_set_pipeline (recorder, pipeline); } /** * shell_recorder_record: * @recorder: the #ShellRecorder * * Starts recording, or continues a recording that was previously * paused. Starting the recording may fail if the output file * cannot be opened, or if the output stream cannot be created * for other reasons. In that case a warning is printed to * stderr. There is no way currently to get details on how * recording failed to start. * * An extra reference count is added to the recorder if recording * is succesfully started; the recording object will not be freed * until recording is stopped even if the creator no longer holds * a reference. Recording is automatically stopped if the stage * is destroyed. * * Return value: %TRUE if recording was succesfully started */ gboolean shell_recorder_record (ShellRecorder *recorder) { g_return_val_if_fail (SHELL_IS_RECORDER (recorder), FALSE); g_return_val_if_fail (recorder->stage != NULL, FALSE); g_return_val_if_fail (recorder->state != RECORDER_STATE_RECORDING, FALSE); if (recorder->current_pipeline) { /* Adjust the start time so that the times in the stream ignore the * pause */ recorder->start_time = recorder->start_time + (get_wall_time() - recorder->pause_time); } else { if (!recorder_open_pipeline (recorder)) return FALSE; recorder->start_time = get_wall_time(); } recorder->state = RECORDER_STATE_RECORDING; recorder_add_update_pointer_timeout (recorder); /* Record an initial frame and also redraw with the indicator */ clutter_actor_queue_redraw (CLUTTER_ACTOR (recorder->stage)); /* We keep a ref while recording to let a caller start a recording then * drop their reference to the recorder */ g_object_ref (recorder); return TRUE; } /** * shell_recorder_pause: * @recorder: the #ShellRecorder * * Temporarily stop recording. If the specified filename includes * the %c escape, then the stream is closed and a new stream with * an incremented counter will be created. Otherwise the stream * is paused and will be continued when shell_recorder_record() * is next called. */ void shell_recorder_pause (ShellRecorder *recorder) { g_return_if_fail (SHELL_IS_RECORDER (recorder)); g_return_if_fail (recorder->state == RECORDER_STATE_RECORDING); recorder_remove_update_pointer_timeout (recorder); /* We want to record one more frame since some time may have * elapsed since the last frame */ clutter_actor_paint (CLUTTER_ACTOR (recorder->stage)); if (recorder->filename_has_count) recorder_close_pipeline (recorder); recorder->state = RECORDER_STATE_PAUSED; recorder->pause_time = get_wall_time(); /* Queue a redraw to remove the recording indicator */ clutter_actor_queue_redraw (CLUTTER_ACTOR (recorder->stage)); } /** * shell_recorder_close: * @recorder: the #ShellRecorder * * Stops recording. It's possible to call shell_recorder_record() * again to reopen a new recording stream, but unless change the * recording filename, this may result in the old recording being * overwritten. */ void shell_recorder_close (ShellRecorder *recorder) { g_return_if_fail (SHELL_IS_RECORDER (recorder)); g_return_if_fail (recorder->state != RECORDER_STATE_CLOSED); if (recorder->state == RECORDER_STATE_RECORDING) shell_recorder_pause (recorder); recorder_remove_update_pointer_timeout (recorder); recorder_remove_redraw_timeout (recorder); recorder_close_pipeline (recorder); recorder->state = RECORDER_STATE_CLOSED; recorder->count = 0; g_free (recorder->unique); recorder->unique = NULL; /* Release the refcount we took when we started recording */ g_object_unref (recorder); } /** * shell_recorder_is_recording: * * Determine if recording is currently in progress. (The recorder * is not paused or closed.) * * Return value: %TRUE if the recorder is currently recording. */ gboolean shell_recorder_is_recording (ShellRecorder *recorder) { g_return_val_if_fail (SHELL_IS_RECORDER (recorder), FALSE); return recorder->state == RECORDER_STATE_RECORDING; }