avfilter/palette{gen,use}: misc for-loop cosmetics

Clément Bœsch committed 3 years ago

Commit 11926c41 parent 1340fe72 files · +18 −23Browse files

Unified · Split

2 files

libavfilter/vf_palettegen.c +9 −10
libavfilter/vf_paletteuse.c +9 −13

  */
 static int get_next_box_id_to_split(PaletteGenContext *s)
 {
-    int box_id, best_box_id = -1;
+    int best_box_id = -1;
     int64_t max_score = -1;
     if (s->nb_boxes == s->max_colors - s->reserve_transparent)
         return -1;
-    for (box_id = 0; box_id < s->nb_boxes; box_id++) {
+    for (int box_id = 0; box_id < s->nb_boxes; box_id++) {
         const struct range_box *box = &s->boxes[box_id];
         if (s->boxes[box_id].len >= 2 && box->cut_score > max_score) {
             best_box_id = box_id;
 static void write_palette(AVFilterContext *ctx, AVFrame *out)
 {
     const PaletteGenContext *s = ctx->priv;
-    int x, y, box_id = 0;
+    int box_id = 0;
     uint32_t *pal = (uint32_t *)out->data[0];
     const int pal_linesize = out->linesize[0] >> 2;
     uint32_t last_color = 0;
-    for (y = 0; y < out->height; y++) {
+    for (int y = 0; y < out->height; y++) {
-        for (x = 0; x < out->width; x++) {
+        for (int x = 0; x < out->width; x++) {
             if (box_id < s->nb_boxes) {
                 pal[x] = s->boxes[box_id++].color;
                 if ((x || y) && pal[x] == last_color)
  */
 static struct color_ref **load_color_refs(const struct hist_node *hist, int nb_refs)
 {
-    int i, j, k = 0;
+    int k = 0;
     struct color_ref **refs = av_malloc_array(nb_refs, sizeof(*refs));
     if (!refs)
         return NULL;
-    for (j = 0; j < HIST_SIZE; j++) {
+    for (int j = 0; j < HIST_SIZE; j++) {
         const struct hist_node *node = &hist[j];
-        for (i = 0; i < node->nb_entries; i++)
+        for (int i = 0; i < node->nb_entries; i++)
             refs[k++] = &node->entries[i];
     }
  */
 static int color_inc(struct hist_node *hist, uint32_t color)
 {
-    int i;
     const uint32_t hash = ff_lowbias32(color) & (HIST_SIZE - 1);
     struct hist_node *node = &hist[hash];
     struct color_ref *e;
-    for (i = 0; i < node->nb_entries; i++) {
+    for (int i = 0; i < node->nb_entries; i++) {
         e = &node->entries[i];
         if (e->color == color) {
             e->count++;

libavfilter/vf_paletteuse.c+9−13

  */
 static av_always_inline int color_get(PaletteUseContext *s, uint32_t color)
 {
-    int i;
     struct color_info clrinfo;
     const uint32_t hash = ff_lowbias32(color) & (CACHE_SIZE - 1);
     struct cache_node *node = &s->cache[hash];
         return s->transparency_index;
     }
-    for (i = 0; i < node->nb_entries; i++) {
+    for (int i = 0; i < node->nb_entries; i++) {
         e = &node->entries[i];
         if (e->color == color)
             return e->pal_entry;
                                       int x_start, int y_start, int w, int h,
                                       enum dithering_mode dither)
 {
-    int x, y;
     const int src_linesize = in ->linesize[0] >> 2;
     const int dst_linesize = out->linesize[0];
     uint32_t *src = ((uint32_t *)in ->data[0]) + y_start*src_linesize;
     w += x_start;
     h += y_start;
-    for (y = y_start; y < h; y++) {
+    for (int y = y_start; y < h; y++) {
-        for (x = x_start; x < w; x++) {
+        for (int x = x_start; x < w; x++) {
             int er, eg, eb;
             if (dither == DITHERING_BAYER) {
                           int *component, const struct color_rect *box)
 {
     int wL, wa, wb;
-    int i, longest = 0;
+    int longest = 0;
     unsigned nb_color = 0;
     struct color_rect ranges;
     struct color tmp_pal[256];
     ranges.min[0] = ranges.min[1] = ranges.min[2] = 0xffff;
     ranges.max[0] = ranges.max[1] = ranges.max[2] = -0xffff;
-    for (i = 0; i < AVPALETTE_COUNT; i++) {
+    for (int i = 0; i < AVPALETTE_COUNT; i++) {
         const uint32_t c = palette[i];
         const uint8_t a = c >> 24;
         const struct Lab lab = ff_srgb_u8_to_oklab_int(c);
 static void load_colormap(PaletteUseContext *s)
 {
-    int i, nb_used = 0;
+    int nb_used = 0;
     uint8_t color_used[AVPALETTE_COUNT] = {0};
     uint32_t last_color = 0;
     struct color_rect box;
     /* disable transparent colors and dups */
     qsort(s->palette, AVPALETTE_COUNT-(s->transparency_index >= 0), sizeof(*s->palette), cmp_pal_entry);
-    for (i = 0; i < AVPALETTE_COUNT; i++) {
+    for (int i = 0; i < AVPALETTE_COUNT; i++) {
         const uint32_t c = s->palette[i];
         if (i != 0 && c == last_color) {
             color_used[i] = 1;
     s->set_frame = set_frame_lut[s->dither];
     if (s->dither == DITHERING_BAYER) {
-        int i;
         const int delta = 1 << (5 - s->bayer_scale); // to avoid too much luma
-        for (i = 0; i < FF_ARRAY_ELEMS(s->ordered_dither); i++)
+        for (int i = 0; i < FF_ARRAY_ELEMS(s->ordered_dither); i++)
             s->ordered_dither[i] = (dither_value(i) >> s->bayer_scale) - delta;
     }
 static av_cold void uninit(AVFilterContext *ctx)
 {
-    int i;
     PaletteUseContext *s = ctx->priv;
     ff_framesync_uninit(&s->fs);
-    for (i = 0; i < CACHE_SIZE; i++)
+    for (int i = 0; i < CACHE_SIZE; i++)
         av_freep(&s->cache[i].entries);
     av_frame_free(&s->last_in);
     av_frame_free(&s->last_out);

avfilter/palette{gen,use}: misc for-loop cosmetics

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code