ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 138 insertions, 134 deletions

diff --git a/source/blender/blenkernel/intern/seqcache.c b/source/blender/blenkernel/intern/seqcache.c
index 14d6fb0a17e..7024bafd988 100644
--- a/source/blender/blenkernel/intern/seqcache.c
+++ b/source/blender/blenkernel/intern/seqcache.c
@@ -22,7 +22,7 @@
 
 #include <stddef.h>
 
-#include "BLI_sys_types.h"  /* for intptr_t */
+#include "BLI_sys_types.h" /* for intptr_t */
 
 #include "MEM_guardedalloc.h"
 
@@ -39,25 +39,25 @@
 #include "BKE_scene.h"
 
 typedef struct SeqCacheKey {
-	struct Sequence *seq;
-	SeqRenderData context;
-	float cfra;
-	eSeqStripElemIBuf type;
+  struct Sequence *seq;
+  SeqRenderData context;
+  float cfra;
+  eSeqStripElemIBuf type;
 } SeqCacheKey;
 
 typedef struct SeqPreprocessCacheElem {
-	struct SeqPreprocessCacheElem *next, *prev;
+  struct SeqPreprocessCacheElem *next, *prev;
 
-	struct Sequence *seq;
-	SeqRenderData context;
-	eSeqStripElemIBuf type;
+  struct Sequence *seq;
+  SeqRenderData context;
+  eSeqStripElemIBuf type;
 
-	ImBuf *ibuf;
+  ImBuf *ibuf;
 } SeqPreprocessCacheElem;
 
 typedef struct SeqPreprocessCache {
-	int cfra;
-	ListBase elems;
+  int cfra;
+  ListBase elems;
 } SeqPreprocessCache;
 
 static struct MovieCache *moviecache = NULL;
@@ -67,215 +67,219 @@ static void preprocessed_cache_destruct(void);
 
 static bool seq_cmp_render_data(const SeqRenderData *a, const SeqRenderData *b)
 {
-	return ((a->preview_render_size != b->preview_render_size) ||
-	        (a->rectx != b->rectx) ||
-	        (a->recty != b->recty) ||
-	        (a->bmain != b->bmain) ||
-	        (a->scene != b->scene) ||
-	        (a->motion_blur_shutter != b->motion_blur_shutter) ||
-	        (a->motion_blur_samples != b->motion_blur_samples) ||
-	        (a->scene->r.views_format != b->scene->r.views_format) ||
-	        (a->view_id != b->view_id));
+  return ((a->preview_render_size != b->preview_render_size) || (a->rectx != b->rectx) ||
+          (a->recty != b->recty) || (a->bmain != b->bmain) || (a->scene != b->scene) ||
+          (a->motion_blur_shutter != b->motion_blur_shutter) ||
+          (a->motion_blur_samples != b->motion_blur_samples) ||
+          (a->scene->r.views_format != b->scene->r.views_format) || (a->view_id != b->view_id));
 }
 
 static unsigned int seq_hash_render_data(const SeqRenderData *a)
 {
-	unsigned int rval = a->rectx + a->recty;
+  unsigned int rval = a->rectx + a->recty;
 
-	rval ^= a->preview_render_size;
-	rval ^= ((intptr_t) a->bmain) << 6;
-	rval ^= ((intptr_t) a->scene) << 6;
-	rval ^= (int)(a->motion_blur_shutter * 100.0f) << 10;
-	rval ^= a->motion_blur_samples << 16;
-	rval ^= ((a->scene->r.views_format * 2) + a->view_id) << 24;
+  rval ^= a->preview_render_size;
+  rval ^= ((intptr_t)a->bmain) << 6;
+  rval ^= ((intptr_t)a->scene) << 6;
+  rval ^= (int)(a->motion_blur_shutter * 100.0f) << 10;
+  rval ^= a->motion_blur_samples << 16;
+  rval ^= ((a->scene->r.views_format * 2) + a->view_id) << 24;
 
-	return rval;
+  return rval;
 }
 
 static unsigned int seqcache_hashhash(const void *key_)
 {
-	const SeqCacheKey *key = key_;
-	unsigned int rval = seq_hash_render_data(&key->context);
+  const SeqCacheKey *key = key_;
+  unsigned int rval = seq_hash_render_data(&key->context);
 
-	rval ^= *(const unsigned int *) &key->cfra;
-	rval += key->type;
-	rval ^= ((intptr_t) key->seq) << 6;
+  rval ^= *(const unsigned int *)&key->cfra;
+  rval += key->type;
+  rval ^= ((intptr_t)key->seq) << 6;
 
-	return rval;
+  return rval;
 }
 
 static bool seqcache_hashcmp(const void *a_, const void *b_)
 {
-	const SeqCacheKey *a = a_;
-	const SeqCacheKey *b = b_;
+  const SeqCacheKey *a = a_;
+  const SeqCacheKey *b = b_;
 
-	return ((a->seq != b->seq) ||
-	        (a->cfra != b->cfra) ||
-	        (a->type != b->type) ||
-	        seq_cmp_render_data(&a->context, &b->context));
+  return ((a->seq != b->seq) || (a->cfra != b->cfra) || (a->type != b->type) ||
+          seq_cmp_render_data(&a->context, &b->context));
 }
 
 void BKE_sequencer_cache_destruct(void)
 {
-	if (moviecache)
-		IMB_moviecache_free(moviecache);
+  if (moviecache)
+    IMB_moviecache_free(moviecache);
 
-	preprocessed_cache_destruct();
+  preprocessed_cache_destruct();
 }
 
 void BKE_sequencer_cache_cleanup(void)
 {
-	if (moviecache) {
-		IMB_moviecache_free(moviecache);
-		moviecache = IMB_moviecache_create("seqcache", sizeof(SeqCacheKey), seqcache_hashhash, seqcache_hashcmp);
-	}
+  if (moviecache) {
+    IMB_moviecache_free(moviecache);
+    moviecache = IMB_moviecache_create(
+        "seqcache", sizeof(SeqCacheKey), seqcache_hashhash, seqcache_hashcmp);
+  }
 
-	BKE_sequencer_preprocessed_cache_cleanup();
+  BKE_sequencer_preprocessed_cache_cleanup();
 }
 
 static bool seqcache_key_check_seq(ImBuf *UNUSED(ibuf), void *userkey, void *userdata)
 {
-	SeqCacheKey *key = (SeqCacheKey *) userkey;
-	Sequence *seq = (Sequence *) userdata;
+  SeqCacheKey *key = (SeqCacheKey *)userkey;
+  Sequence *seq = (Sequence *)userdata;
 
-	return key->seq == seq;
+  return key->seq == seq;
 }
 
 void BKE_sequencer_cache_cleanup_sequence(Sequence *seq)
 {
-	if (moviecache)
-		IMB_moviecache_cleanup(moviecache, seqcache_key_check_seq, seq);
+  if (moviecache)
+    IMB_moviecache_cleanup(moviecache, seqcache_key_check_seq, seq);
 }
 
-struct ImBuf *BKE_sequencer_cache_get(const SeqRenderData *context, Sequence *seq, float cfra, eSeqStripElemIBuf type)
+struct ImBuf *BKE_sequencer_cache_get(const SeqRenderData *context,
+                                      Sequence *seq,
+                                      float cfra,
+                                      eSeqStripElemIBuf type)
 {
-	if (moviecache && seq) {
-		SeqCacheKey key;
+  if (moviecache && seq) {
+    SeqCacheKey key;
 
-		key.seq = seq;
-		key.context = *context;
-		key.cfra = cfra - seq->start;
-		key.type = type;
+    key.seq = seq;
+    key.context = *context;
+    key.cfra = cfra - seq->start;
+    key.type = type;
 
-		return IMB_moviecache_get(moviecache, &key);
-	}
+    return IMB_moviecache_get(moviecache, &key);
+  }
 
-	return NULL;
+  return NULL;
 }
 
-void BKE_sequencer_cache_put(const SeqRenderData *context, Sequence *seq, float cfra, eSeqStripElemIBuf type, ImBuf *i)
+void BKE_sequencer_cache_put(
+    const SeqRenderData *context, Sequence *seq, float cfra, eSeqStripElemIBuf type, ImBuf *i)
 {
-	SeqCacheKey key;
+  SeqCacheKey key;
 
-	if (i == NULL || context->skip_cache) {
-		return;
-	}
+  if (i == NULL || context->skip_cache) {
+    return;
+  }
 
-	if (!moviecache) {
-		moviecache = IMB_moviecache_create("seqcache", sizeof(SeqCacheKey), seqcache_hashhash, seqcache_hashcmp);
-	}
+  if (!moviecache) {
+    moviecache = IMB_moviecache_create(
+        "seqcache", sizeof(SeqCacheKey), seqcache_hashhash, seqcache_hashcmp);
+  }
 
-	key.seq = seq;
-	key.context = *context;
-	key.cfra = cfra - seq->start;
-	key.type = type;
+  key.seq = seq;
+  key.context = *context;
+  key.cfra = cfra - seq->start;
+  key.type = type;
 
-	IMB_moviecache_put(moviecache, &key, i);
+  IMB_moviecache_put(moviecache, &key, i);
 }
 
 void BKE_sequencer_preprocessed_cache_cleanup(void)
 {
-	SeqPreprocessCacheElem *elem;
+  SeqPreprocessCacheElem *elem;
 
-	if (!preprocess_cache)
-		return;
+  if (!preprocess_cache)
+    return;
 
-	for (elem = preprocess_cache->elems.first; elem; elem = elem->next) {
-		IMB_freeImBuf(elem->ibuf);
-	}
-	BLI_freelistN(&preprocess_cache->elems);
+  for (elem = preprocess_cache->elems.first; elem; elem = elem->next) {
+    IMB_freeImBuf(elem->ibuf);
+  }
+  BLI_freelistN(&preprocess_cache->elems);
 
-	BLI_listbase_clear(&preprocess_cache->elems);
+  BLI_listbase_clear(&preprocess_cache->elems);
 }
 
 static void preprocessed_cache_destruct(void)
 {
-	if (!preprocess_cache)
-		return;
+  if (!preprocess_cache)
+    return;
 
-	BKE_sequencer_preprocessed_cache_cleanup();
+  BKE_sequencer_preprocessed_cache_cleanup();
 
-	MEM_freeN(preprocess_cache);
-	preprocess_cache = NULL;
+  MEM_freeN(preprocess_cache);
+  preprocess_cache = NULL;
 }
 
-ImBuf *BKE_sequencer_preprocessed_cache_get(const SeqRenderData *context, Sequence *seq, float cfra, eSeqStripElemIBuf type)
+ImBuf *BKE_sequencer_preprocessed_cache_get(const SeqRenderData *context,
+                                            Sequence *seq,
+                                            float cfra,
+                                            eSeqStripElemIBuf type)
 {
-	SeqPreprocessCacheElem *elem;
+  SeqPreprocessCacheElem *elem;
 
-	if (!preprocess_cache)
-		return NULL;
+  if (!preprocess_cache)
+    return NULL;
 
-	if (preprocess_cache->cfra != cfra)
-		return NULL;
+  if (preprocess_cache->cfra != cfra)
+    return NULL;
 
-	for (elem = preprocess_cache->elems.first; elem; elem = elem->next) {
-		if (elem->seq != seq)
-			continue;
+  for (elem = preprocess_cache->elems.first; elem; elem = elem->next) {
+    if (elem->seq != seq)
+      continue;
 
-		if (elem->type != type)
-			continue;
+    if (elem->type != type)
+      continue;
 
-		if (seq_cmp_render_data(&elem->context, context) != 0)
-			continue;
+    if (seq_cmp_render_data(&elem->context, context) != 0)
+      continue;
 
-		IMB_refImBuf(elem->ibuf);
-		return elem->ibuf;
-	}
+    IMB_refImBuf(elem->ibuf);
+    return elem->ibuf;
+  }
 
-	return NULL;
+  return NULL;
 }
 
-void BKE_sequencer_preprocessed_cache_put(const SeqRenderData *context, Sequence *seq, float cfra, eSeqStripElemIBuf type, ImBuf *ibuf)
+void BKE_sequencer_preprocessed_cache_put(
+    const SeqRenderData *context, Sequence *seq, float cfra, eSeqStripElemIBuf type, ImBuf *ibuf)
 {
-	SeqPreprocessCacheElem *elem;
+  SeqPreprocessCacheElem *elem;
 
-	if (!preprocess_cache) {
-		preprocess_cache = MEM_callocN(sizeof(SeqPreprocessCache), "sequencer preprocessed cache");
-	}
-	else {
-		if (preprocess_cache->cfra != cfra)
-			BKE_sequencer_preprocessed_cache_cleanup();
-	}
+  if (!preprocess_cache) {
+    preprocess_cache = MEM_callocN(sizeof(SeqPreprocessCache), "sequencer preprocessed cache");
+  }
+  else {
+    if (preprocess_cache->cfra != cfra)
+      BKE_sequencer_preprocessed_cache_cleanup();
+  }
 
-	elem = MEM_callocN(sizeof(SeqPreprocessCacheElem), "sequencer preprocessed cache element");
+  elem = MEM_callocN(sizeof(SeqPreprocessCacheElem), "sequencer preprocessed cache element");
 
-	elem->seq = seq;
-	elem->type = type;
-	elem->context = *context;
-	elem->ibuf = ibuf;
+  elem->seq = seq;
+  elem->type = type;
+  elem->context = *context;
+  elem->ibuf = ibuf;
 
-	preprocess_cache->cfra = cfra;
+  preprocess_cache->cfra = cfra;
 
-	IMB_refImBuf(ibuf);
+  IMB_refImBuf(ibuf);
 
-	BLI_addtail(&preprocess_cache->elems, elem);
+  BLI_addtail(&preprocess_cache->elems, elem);
 }
 
 void BKE_sequencer_preprocessed_cache_cleanup_sequence(Sequence *seq)
 {
-	SeqPreprocessCacheElem *elem, *elem_next;
+  SeqPreprocessCacheElem *elem, *elem_next;
 
-	if (!preprocess_cache)
-		return;
+  if (!preprocess_cache)
+    return;
 
-	for (elem = preprocess_cache->elems.first; elem; elem = elem_next) {
-		elem_next = elem->next;
+  for (elem = preprocess_cache->elems.first; elem; elem = elem_next) {
+    elem_next = elem->next;
 
-		if (elem->seq == seq) {
-			IMB_freeImBuf(elem->ibuf);
+    if (elem->seq == seq) {
+      IMB_freeImBuf(elem->ibuf);
 
-			BLI_freelinkN(&preprocess_cache->elems, elem);
-		}
-	}
+      BLI_freelinkN(&preprocess_cache->elems, elem);
+    }
+  }
 }