static void
append_renderer (GtkSourceGutter *gutter,
Renderer *renderer)
{
gutter->priv->renderers =
g_list_insert_sorted_with_data (gutter->priv->renderers,
renderer,
(GCompareDataFunc)sort_by_position,
NULL);
update_gutter_size (gutter);
}
GList *
string_list_append_sorted (GList *str_list, const char *string)
{
g_return_val_if_fail (string != NULL, str_list);
if (string_list_is_exists(str_list, string))
return str_list;
str_list = g_list_insert_sorted_with_data (str_list, g_strdup(string),
(GCompareDataFunc)g_strcmp0, NULL);
return str_list;
}
static GList *
get_independent_commits (GList *commits)
{
SeafCommit **rslt;
GList *list, *result;
int cnt, i, j;
SeafCommit *c;
g_debug ("Get independent commits.\n");
cnt = g_list_length (commits);
rslt = calloc(cnt, sizeof(*rslt));
for (list = commits, i = 0; list; list = list->next)
rslt[i++] = list->data;
g_list_free (commits);
for (i = 0; i < cnt - 1; i++) {
for (j = i+1; j < cnt; j++) {
if (!rslt[i] || !rslt[j])
continue;
result = merge_bases_many(rslt[i], 1, &rslt[j]);
for (list = result; list; list = list->next) {
c = list->data;
/* If two commits have fast-forward relationship,
* drop the older one.
*/
if (strcmp (rslt[i]->commit_id, c->commit_id) == 0) {
seaf_commit_unref (rslt[i]);
rslt[i] = NULL;
}
if (strcmp (rslt[j]->commit_id, c->commit_id) == 0) {
seaf_commit_unref (rslt[j]);
rslt[j] = NULL;
}
seaf_commit_unref (c);
}
}
}
/* Surviving ones in rslt[] are the independent results */
result = NULL;
for (i = 0; i < cnt; i++) {
if (rslt[i])
result = g_list_insert_sorted_with_data (result, rslt[i],
compare_commit_by_time,
NULL);
}
free(rslt);
return result;
}
static void
gst_rtp_ulpfec_dec_start (GstRtpUlpFecDec * self, GstBufferList * buflist,
guint8 fec_pt, guint16 lost_seq)
{
guint fec_packets = 0;
gsize i;
g_assert (NULL == self->info_media);
g_assert (0 == self->info_fec->len);
g_assert (0 == self->info_arr->len);
g_array_set_size (self->info_arr, gst_buffer_list_length (buflist));
for (i = 0;
i < gst_buffer_list_length (buflist) && !self->lost_packet_from_storage;
++i) {
GstBuffer *buffer = gst_buffer_list_get (buflist, i);
RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, i);
if (!rtp_ulpfec_map_info_map (gst_buffer_ref (buffer), info))
g_assert_not_reached ();
if (fec_pt == gst_rtp_buffer_get_payload_type (&info->rtp)) {
GST_DEBUG_RTP_PACKET (self, "rtp header (fec)", &info->rtp);
++fec_packets;
if (rtp_ulpfec_buffer_is_valid (&info->rtp)) {
GST_DEBUG_FEC_PACKET (self, &info->rtp);
g_ptr_array_add (self->info_fec, GUINT_TO_POINTER (i));
}
} else {
GST_LOG_RTP_PACKET (self, "rtp header (incoming)", &info->rtp);
if (lost_seq == gst_rtp_buffer_get_seq (&info->rtp)) {
GST_DEBUG_OBJECT (self, "Received lost packet from from the storage");
g_list_free (self->info_media);
self->info_media = NULL;
self->lost_packet_from_storage = TRUE;
}
self->info_media =
g_list_insert_sorted_with_data (self->info_media,
GUINT_TO_POINTER (i), _compare_fec_map_info, self);
}
}
if (!self->lost_packet_from_storage) {
self->fec_packets_received += fec_packets;
self->fec_packets_rejected += fec_packets - self->info_fec->len;
}
}
/**
* ggd_tag_sort_by_line_to_list:
* @tags: A #GPtrArray of #TMTag<!-- -->s
* @direction: Sort direction: %GGD_SORT_ASC for an ascending sort or
* %GGD_SORT_DESC for a descending sort.
*
* Creates a sorted list of tags from a #GPtrArray of #TMTag<!-- -->s. The list
* is sorted by the tags' line position. The sort direction depend on
* @direction.
*
* <note><para>The tags are not copied; you must then not free the array' items
* if you still want to use the returned list.</para></note>
*
* Returns: A newly created list of tags that should be freed with
* g_list_free().
*/
GList *
ggd_tag_sort_by_line_to_list (const GPtrArray *tags,
gint direction)
{
GList *children = NULL;
guint i;
TMTag *el;
g_return_val_if_fail (tags != NULL, NULL);
g_return_val_if_fail (direction != 0, NULL);
GGD_PTR_ARRAY_FOR (tags, i, el) {
children = g_list_insert_sorted_with_data (children, el,
tag_cmp_by_line,
GINT_TO_POINTER (direction));
}
static gboolean
get_merge_bases (SeafCommit *commit, void *vdata, gboolean *stop)
{
MergeTraverseData *data = vdata;
/* Found a common ancestor.
* Dont traverse its parenets.
*/
if (g_hash_table_lookup (data->commit_hash, commit->commit_id)) {
if (!g_list_find_custom (data->result, commit, compare_commit)) {
data->result = g_list_insert_sorted_with_data (data->result, commit,
compare_commit_by_time,
NULL);
seaf_commit_ref (commit);
}
*stop = TRUE;
}
return TRUE;
}
static void
mex_column_add (ClutterContainer *container,
ClutterActor *actor)
{
MexColumn *self = MEX_COLUMN (container);
MexColumnPrivate *priv = self->priv;
if (priv->sort_func)
priv->children =
g_list_insert_sorted_with_data (priv->children, actor,
(GCompareDataFunc)priv->sort_func,
priv->sort_data);
else
priv->children = g_list_append (priv->children, actor);
priv->n_items ++;
/* Expand/collapse any drawer that gets added as appropriate */
if (MEX_IS_EXPANDER_BOX (actor))
{
g_signal_connect (actor, "notify::open",
G_CALLBACK (expander_box_open_notify), container);
mex_expander_box_set_important (MEX_EXPANDER_BOX (actor),
priv->has_focus);
if (MEX_IS_CONTENT_BOX (actor))
{
ClutterActor *tile =
mex_content_box_get_tile (MEX_CONTENT_BOX (actor));
mex_tile_set_important (MEX_TILE (tile), priv->has_focus);
}
}
clutter_actor_set_parent (actor, CLUTTER_ACTOR (self));
g_signal_emit_by_name (self, "actor-added", actor);
}
static GstBuffer *
gst_rtp_ulpfec_dec_recover_from_fec (GstRtpUlpFecDec * self,
RtpUlpFecMapInfo * info_fec, guint32 ssrc, gint media_pt, guint16 seq,
guint8 * dst_pt)
{
guint64 fec_mask = rtp_ulpfec_buffer_get_mask (&info_fec->rtp);
gboolean fec_mask_long = rtp_ulpfec_buffer_get_fechdr (&info_fec->rtp)->L;
guint16 fec_seq_base = rtp_ulpfec_buffer_get_seq_base (&info_fec->rtp);
GstBuffer *ret;
GList *it;
g_array_set_size (self->scratch_buf, 0);
rtp_buffer_to_ulpfec_bitstring (&info_fec->rtp, self->scratch_buf, TRUE,
fec_mask_long);
for (it = self->info_media; it; it = it->next) {
RtpUlpFecMapInfo *info = RTP_FEC_MAP_INFO_NTH (self, it->data);
guint64 packet_mask =
rtp_ulpfec_packet_mask_from_seqnum (gst_rtp_buffer_get_seq (&info->rtp),
fec_seq_base, TRUE);
if (fec_mask & packet_mask) {
fec_mask ^= packet_mask;
rtp_buffer_to_ulpfec_bitstring (&info->rtp, self->scratch_buf, FALSE,
fec_mask_long);
}
}
ret =
rtp_ulpfec_bitstring_to_media_rtp_buffer (self->scratch_buf,
fec_mask_long, ssrc, seq);
if (ret) {
/* We are about to put recovered packet back in self->info_media to be able
* to reuse it later for recovery of other packets
**/
gint i = self->info_arr->len;
RtpUlpFecMapInfo *info;
guint8 recovered_pt;
g_array_set_size (self->info_arr, self->info_arr->len + 1);
info = RTP_FEC_MAP_INFO_NTH (self, i);
if (!rtp_ulpfec_map_info_map (gst_buffer_ref (ret), info)) {
GST_WARNING_OBJECT (self, "Invalid recovered packet");
goto recovered_packet_invalid;
}
recovered_pt = gst_rtp_buffer_get_payload_type (&info->rtp);
if (!gst_rtp_ulpfec_dec_is_recovered_pt_valid (self, media_pt,
recovered_pt)) {
GST_WARNING_OBJECT (self,
"Recovered packet has unexpected payload type (%u)", recovered_pt);
goto recovered_packet_invalid;
}
GST_DEBUG_RTP_PACKET (self, "rtp header (recovered)", &info->rtp);
self->info_media =
g_list_insert_sorted_with_data (self->info_media, GUINT_TO_POINTER (i),
_compare_fec_map_info, self);
*dst_pt = recovered_pt;
}
return ret;
recovered_packet_invalid:
g_array_set_size (self->info_arr, self->info_arr->len - 1);
gst_buffer_unref (ret);
return NULL;
}
static void
mex_proxy_controller_changed_cb (GController *controller,
GControllerAction action,
GControllerReference *ref,
MexProxy *proxy)
{
gint i, n_indices;
MexContent *content;
MexProxyPrivate *priv = proxy->priv;
n_indices = g_controller_reference_get_n_indices (ref);
switch (action)
{
case G_CONTROLLER_ADD:
for (i = 0; i < n_indices; i++)
{
gint content_index = g_controller_reference_get_index_uint (ref, i);
content = mex_model_get_content (priv->model, content_index);
mex_proxy_add_content (proxy, content);
}
break;
case G_CONTROLLER_REMOVE:
{
gint length, fillin = 0, start_fillin;
GList *positions = NULL, *position;
for (i = 0; i < n_indices; i++)
{
gint content_index = g_controller_reference_get_index_uint (ref, i);
if (content_index >= priv->limit)
positions = g_list_insert_sorted_with_data (positions,
GINT_TO_POINTER (content_index),
_insert_position,
NULL);
else
fillin++;
content = mex_model_get_content (priv->model, content_index);
mex_proxy_remove_content (proxy, content);
}
position = positions;
length = mex_model_get_length (priv->model);
start_fillin = priv->limit;
for (i = 0;
i < MIN (fillin, (length - (gint) priv->limit));
i++)
{
if ((position != NULL) &&
(start_fillin == GPOINTER_TO_INT (position->data)))
{
while ((position != NULL) &&
(start_fillin == GPOINTER_TO_INT (position->data)))
{
start_fillin++;
if (start_fillin > GPOINTER_TO_INT (position->data))
position = position->next;
}
}
content = mex_model_get_content (priv->model, start_fillin);
mex_proxy_add_content (proxy, content);
start_fillin++;
}
g_list_free (positions);
}
break;
case G_CONTROLLER_UPDATE:
/* Should be no need for this, GBinding sorts it out for us :) */
break;
case G_CONTROLLER_CLEAR:
mex_proxy_clear (proxy);
break;
case G_CONTROLLER_REPLACE:
mex_proxy_clear (proxy);
i = 0;
while ((content = mex_model_get_content (priv->model, i++)))
mex_proxy_add_content (proxy, content);
break;
case G_CONTROLLER_INVALID_ACTION:
g_warning (G_STRLOC ": Proxy controller has issued an error");
break;
default:
g_warning (G_STRLOC ": Unhandled action");
break;
}
}
