Skip to contentSkip to conversation

yavta: Format type errors for non x86 arches

PATCH In review Ricardo Ribalda 3 participants 8 messages Sep 19, 2023 – Sep 20, 2023 Media (V4L/DVB)

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 yavta: Format type errors for non x86 arches

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
yavta.c +21 -14
index d562863..bf54e4f 100644
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
 			printf("  %u: %.32s%s\n", menu.index, menu.name,
 			       menu.index == value ? " (*)" : "");
 		else
-			printf("  %u: %lld%s\n", menu.index, menu.value,
+			printf("  %u: %lld%s\n", menu.index,
+			       (long long)menu.value,
 			       menu.index == value ? " (*)" : "");
 	};
 }
@@ -1360,7 +1361,7 @@ static void video_print_control_value(const struct v4l2_query_ext_ctrl *query,
 			printf("0x%08x", ctrl->value);
 			break;
 		case V4L2_CTRL_TYPE_INTEGER64:
-			printf("%lld", ctrl->value64);
+			printf("%lld", (long long)ctrl->value64);
 			break;
 		case V4L2_CTRL_TYPE_STRING:
 			printf("%s", ctrl->string);
@@ -1399,9 +1400,11 @@ static int video_get_control(struct device *dev,
 	}
 
 	if (full) {
-		printf("control 0x%08x `%s' min %lld max %lld step %lld default %lld ",
-			query->id, query->name, query->minimum, query->maximum,
-			query->step, query->default_value);
+		printf("control 0x%08x `%s' min %lld max %lld step %llu default %lld ",
+		       query->id, query->name, (long long)query->minimum,
+		       (long long)query->maximum,
+		       (unsigned long long)query->step,
+		       (long long)query->default_value);
 		if (query->nr_of_dims) {
 			for (i = 0; i < query->nr_of_dims; ++i)
 				printf("[%u]", query->dims[i]);
@@ -2190,13 +2193,16 @@ static int video_do_capture(struct device *dev, unsigned int nframes,
 
 		clock_gettime(CLOCK_MONOTONIC, &ts);
 		get_ts_flags(buf.flags, &ts_type, &ts_source);
-		printf("%u (%u) [%c] %s %u %u B %ld.%06ld %ld.%06ld %.3f fps ts %s/%s\n", i, buf.index,
-			(buf.flags & V4L2_BUF_FLAG_ERROR) ? 'E' : '-',
-			v4l2_field_name(buf.field),
-			buf.sequence, video_buffer_bytes_used(dev, &buf),
-			buf.timestamp.tv_sec, buf.timestamp.tv_usec,
-			ts.tv_sec, ts.tv_nsec/1000, fps,
-			ts_type, ts_source);
+		printf("%u (%u) [%c] %s %u %u B %lld.%06lld %lld.%06lld %.3f fps ts %s/%s\n",
+		       i, buf.index,
+		       (buf.flags & V4L2_BUF_FLAG_ERROR) ? 'E' : '-',
+		       v4l2_field_name(buf.field),
+		       buf.sequence, video_buffer_bytes_used(dev, &buf),
+		       (long long)buf.timestamp.tv_sec,
+		       (long long)buf.timestamp.tv_usec,
+		       (long long)ts.tv_sec,
+		       (long long)(ts.tv_nsec / 1000), fps,
+		       ts_type, ts_source);
 
 		last = buf.timestamp;
 
@@ -2252,8 +2258,9 @@ static int video_do_capture(struct device *dev, unsigned int nframes,
 	bps = size/(ts.tv_nsec/1000.0+1000000.0*ts.tv_sec)*1000000.0;
 	fps = i/(ts.tv_nsec/1000.0+1000000.0*ts.tv_sec)*1000000.0;
 
-	printf("Captured %u frames in %lu.%06lu seconds (%f fps, %f B/s).\n",
-		i, ts.tv_sec, ts.tv_nsec/1000, fps, bps);
+	printf("Captured %u frames in %llu.%06llu seconds (%f fps, %f B/s).\n",
+	       i, (long long)ts.tv_sec, (long long)(ts.tv_nsec / 1000), fps,
+	       bps);
 
 done:
 	video_free_buffers(dev);
Signature · 1 line
2.30.2
#1 lore raw

Hi Ricardo,

Thanks for the patch.

Quoted 18 lines · Ricardo Ribalda

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
yavta.c +0 -0
index d562863..bf54e4f 100644

yavta.c static void video_query_menu(struct device *dev, · line 1316

Quoted 5 lines
yavta.c +1 -1
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
 			printf("  %u: %.32s%s\n", menu.index, menu.name,
 			       menu.index == value ? " (*)" : "");
 		else
-			printf("  %u: %lld%s\n", menu.index, menu.value,
+			printf("  %u: %lld%s\n", menu.index,

Could you instead use PRId64 for this? You can avoid casting to another type this way. Same for the other cases.

Quoted 4 lines
yavta.c +1 -0
+			       (long long)menu.value,
 			       menu.index == value ? " (*)" : "");
 	};
 }
Signature · 3 lines
Regards,

Sakari Ailus
#2 lore raw

Hi Sakari

Quoted 19 lines · Sakari Ailus

Hi Ricardo,

Thanks for the patch.

Quoted 13 lines · Ricardo Ribalda

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
Quoted 13 lines

yavta.c static void video_query_menu(struct device *dev, · line 1316

Quoted 10 lines
yavta.c +1 -1
index d562863..bf54e4f 100644
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
                      printf("  %u: %.32s%s\n", menu.index, menu.name,
                             menu.index == value ? " (*)" : "");
              else
-                     printf("  %u: %lld%s\n", menu.index, menu.value,
+                     printf("  %u: %lld%s\n", menu.index,

Could you instead use PRId64 for this? You can avoid casting to another type this way. Same for the other cases.

Already tried this:

@@ -1313,7 +1313,7 @@ static void video_query_menu(struct device *dev,

                        printf("  %u: %.32s%s\n", menu.index, menu.name,
                               menu.index == value ? " (*)" : "");
                else
-                       printf("  %u: %lld%s\n", menu.index, menu.value,
+                       printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
                               menu.index == value ? " (*)" : "");
        };

}

but gcc was not happy:

yavta.c: In function ‘video_query_menu’:
yavta.c:1316:11: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 3 has type ‘__s64’ {aka ‘long long int’} [-Wformat=]

 1316 |    printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
      |           ^~~~~~~~~                            ~~~~~~~~~~
      |                                                    |
      |                                                    __s64 {aka

long long int}
In file included from yavta.c:26:
/usr/include/inttypes.h:57:34: note: format string is defined here
57 | # define PRId64 __PRI64_PREFIX "d"

So I took the shotgun and fixed it with castings :)

Quoted 10 lines

yavta.c static void video_query_menu(struct device *dev, · line 1320

Quoted 5 lines
yavta.c +1 -0
+                            (long long)menu.value,
                             menu.index == value ? " (*)" : "");
      };
 }

--
Regards,

Sakari Ailus

Signature · 1 line
Ricardo Ribalda
#3 lore raw

Hi Ricardo,

Quoted 54 lines · Ricardo Ribalda

Hi Sakari

Quoted 19 lines · Sakari Ailus

Hi Ricardo,

Thanks for the patch.

Quoted 13 lines · Ricardo Ribalda

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
Quoted 13 lines

yavta.c static void video_query_menu(struct device *dev, · line 1316

Quoted 10 lines
yavta.c +1 -1
index d562863..bf54e4f 100644
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
                      printf("  %u: %.32s%s\n", menu.index, menu.name,
                             menu.index == value ? " (*)" : "");
              else
-                     printf("  %u: %lld%s\n", menu.index, menu.value,
+                     printf("  %u: %lld%s\n", menu.index,

Could you instead use PRId64 for this? You can avoid casting to another type this way. Same for the other cases.

Already tried this:

yavta.c +1 -1
@@ -1313,7 +1313,7 @@ static void video_query_menu(struct device *dev,
                        printf("  %u: %.32s%s\n", menu.index, menu.name,
                               menu.index == value ? " (*)" : "");
                else
-                       printf("  %u: %lld%s\n", menu.index, menu.value,
+                       printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
                               menu.index == value ? " (*)" : "");
        };
 }

but gcc was not happy:

yavta.c: In function ‘video_query_menu’:
yavta.c:1316:11: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 3 has type ‘__s64’ {aka ‘long long int’} [-Wformat=]

Quoted 8 lines
 1316 |    printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
      |           ^~~~~~~~~                            ~~~~~~~~~~
      |                                                    |
      |                                                    __s64 {aka

long long int}
In file included from yavta.c:26:
/usr/include/inttypes.h:57:34: note: format string is defined here
57 | # define PRId64 __PRI64_PREFIX "d"

I guess I should have expected this...

I'm not sure if it'd be prettier but another option is to use the PRI* macros and explicitly cast to a standard type.

Using the standard types in the V4L2 header would have avoided this issue. I wonder if there's anything to be gained by using the kernel types.

Cc Hans, too.

Quoted 2 lines

So I took the shotgun and fixed it with castings :)

:-)

Signature · 3 lines
Regards,

Sakari Ailus
#4 lore raw
Quoted 68 lines · Sakari Ailus

Hi Ricardo,

Quoted 54 lines · Ricardo Ribalda

Hi Sakari

Quoted 19 lines · Sakari Ailus

Hi Ricardo,

Thanks for the patch.

Quoted 13 lines · Ricardo Ribalda

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
Quoted 13 lines

yavta.c static void video_query_menu(struct device *dev, · line 1316

Quoted 10 lines
yavta.c +1 -1
index d562863..bf54e4f 100644
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
                      printf("  %u: %.32s%s\n", menu.index, menu.name,
                             menu.index == value ? " (*)" : "");
              else
-                     printf("  %u: %lld%s\n", menu.index, menu.value,
+                     printf("  %u: %lld%s\n", menu.index,

Could you instead use PRId64 for this? You can avoid casting to another type this way. Same for the other cases.

Already tried this:

yavta.c +1 -1
@@ -1313,7 +1313,7 @@ static void video_query_menu(struct device *dev,
                        printf("  %u: %.32s%s\n", menu.index, menu.name,
                               menu.index == value ? " (*)" : "");
                else
-                       printf("  %u: %lld%s\n", menu.index, menu.value,
+                       printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
                               menu.index == value ? " (*)" : "");
        };
 }

but gcc was not happy:

yavta.c: In function ‘video_query_menu’:
yavta.c:1316:11: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 3 has type ‘__s64’ {aka ‘long long int’} [-Wformat=]

Quoted 8 lines
 1316 |    printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
      |           ^~~~~~~~~                            ~~~~~~~~~~
      |                                                    |
      |                                                    __s64 {aka

long long int}
In file included from yavta.c:26:
/usr/include/inttypes.h:57:34: note: format string is defined here
57 | # define PRId64 __PRI64_PREFIX "d"

I guess I should have expected this...

Quoted 5 lines

I'm not sure if it'd be prettier but another option is to use the PRI* macros and explicitly cast to a standard type.

Using the standard types in the V4L2 header would have avoided this issue. I wonder if there's anything to be gained by using the kernel types.

The kernel has defined __s64 as signed int int for a long time now, on all architectures, at least since

commit 0c79a8e29b5fcbcbfd611daf9d500cfad8370fcf

Author: Geert Uytterhoeven <[email protected]>
Date:   Thu Jan 23 15:53:43 2014 -0800

asm/types.h: Remove include/asm-generic/int-l64.h

which was merged in v3.14.

According to https://buildd.debian.org/status/package.php?p=yavta,
however, __s64 seems to be defined as long int on some platforms.

/me is puzzled

Quoted 5 lines

Cc Hans, too.

Quoted 1 line

So I took the shotgun and fixed it with castings :)

:-)

Signature · 3 lines
Regards,

Laurent Pinchart
#5 lore raw

Hi Laurent, Hi Sakari

Quoted 70 lines · Laurent Pinchart
Quoted 68 lines · Sakari Ailus

Hi Ricardo,

Quoted 54 lines · Ricardo Ribalda

Hi Sakari

Quoted 19 lines · Sakari Ailus

Hi Ricardo,

Thanks for the patch.

Quoted 13 lines · Ricardo Ribalda

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
Quoted 13 lines

yavta.c static void video_query_menu(struct device *dev, · line 1316

Quoted 10 lines
yavta.c +1 -1
index d562863..bf54e4f 100644
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
                      printf("  %u: %.32s%s\n", menu.index, menu.name,
                             menu.index == value ? " (*)" : "");
              else
-                     printf("  %u: %lld%s\n", menu.index, menu.value,
+                     printf("  %u: %lld%s\n", menu.index,

Could you instead use PRId64 for this? You can avoid casting to another type this way. Same for the other cases.

Already tried this:

yavta.c +1 -1
@@ -1313,7 +1313,7 @@ static void video_query_menu(struct device *dev,
                        printf("  %u: %.32s%s\n", menu.index, menu.name,
                               menu.index == value ? " (*)" : "");
                else
-                       printf("  %u: %lld%s\n", menu.index, menu.value,
+                       printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
                               menu.index == value ? " (*)" : "");
        };
 }

but gcc was not happy:

yavta.c: In function ‘video_query_menu’:
yavta.c:1316:11: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 3 has type ‘__s64’ {aka ‘long long int’} [-Wformat=]

Quoted 8 lines
 1316 |    printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
      |           ^~~~~~~~~                            ~~~~~~~~~~
      |                                                    |
      |                                                    __s64 {aka

long long int}
In file included from yavta.c:26:
/usr/include/inttypes.h:57:34: note: format string is defined here
57 | # define PRId64 __PRI64_PREFIX "d"

I guess I should have expected this...

Quoted 2 lines
Quoted 2 lines

I'm not sure if it'd be prettier but another option is to use the PRI* macros and explicitly cast to a standard type.

I would like to avoid

  printf(" Hello %" PRId64 "\n", (uint64_t) value_s64);

That looks very bad :)

I believe the current casting is the least of the two evils.

Quoted 11 lines
Quoted 3 lines

Using the standard types in the V4L2 header would have avoided this issue. I wonder if there's anything to be gained by using the kernel types.

The kernel has defined __s64 as signed int int for a long time now, on all architectures, at least since

commit 0c79a8e29b5fcbcbfd611daf9d500cfad8370fcf

Author: Geert Uytterhoeven <[email protected]>
Date:   Thu Jan 23 15:53:43 2014 -0800
Quoted 8 lines

asm/types.h: Remove include/asm-generic/int-l64.h

which was merged in v3.14.

According to https://buildd.debian.org/status/package.php?p=yavta,
however, __s64 seems to be defined as long int on some platforms.

/me is puzzled

It does not help that __s64 is long long int and PRId64 is "d". I guess we can say that inttypes and kernel types do not play along?

I guess we need kerntypes.h with proper KPRId64 but that is probably out of scope here.

Thanks!

Quoted 11 lines
Quoted 6 lines

Cc Hans, too.

Quoted 1 line

So I took the shotgun and fixed it with castings :)

:-)

--
Regards,

Laurent Pinchart

Signature · 1 line
Ricardo Ribalda
#6 lore raw

Hi Ricardo,

Quoted 76 lines · Ricardo Ribalda

Hi Laurent, Hi Sakari

Quoted 70 lines · Laurent Pinchart
Quoted 68 lines · Sakari Ailus

Hi Ricardo,

Quoted 54 lines · Ricardo Ribalda

Hi Sakari

Quoted 19 lines · Sakari Ailus

Hi Ricardo,

Thanks for the patch.

Quoted 13 lines · Ricardo Ribalda

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
Quoted 13 lines

yavta.c static void video_query_menu(struct device *dev, · line 1316

Quoted 10 lines
yavta.c +1 -1
index d562863..bf54e4f 100644
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
                      printf("  %u: %.32s%s\n", menu.index, menu.name,
                             menu.index == value ? " (*)" : "");
              else
-                     printf("  %u: %lld%s\n", menu.index, menu.value,
+                     printf("  %u: %lld%s\n", menu.index,

Could you instead use PRId64 for this? You can avoid casting to another type this way. Same for the other cases.

Already tried this:

yavta.c +1 -1
@@ -1313,7 +1313,7 @@ static void video_query_menu(struct device *dev,
                        printf("  %u: %.32s%s\n", menu.index, menu.name,
                               menu.index == value ? " (*)" : "");
                else
-                       printf("  %u: %lld%s\n", menu.index, menu.value,
+                       printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
                               menu.index == value ? " (*)" : "");
        };
 }

but gcc was not happy:

yavta.c: In function ‘video_query_menu’:
yavta.c:1316:11: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 3 has type ‘__s64’ {aka ‘long long int’} [-Wformat=]

Quoted 8 lines
 1316 |    printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
      |           ^~~~~~~~~                            ~~~~~~~~~~
      |                                                    |
      |                                                    __s64 {aka

long long int}
In file included from yavta.c:26:
/usr/include/inttypes.h:57:34: note: format string is defined here
57 | # define PRId64 __PRI64_PREFIX "d"

I guess I should have expected this...

Quoted 8 lines
Quoted 2 lines
Quoted 2 lines

I'm not sure if it'd be prettier but another option is to use the PRI* macros and explicitly cast to a standard type.

I would like to avoid

  printf(" Hello %" PRId64 "\n", (uint64_t) value_s64);

That looks very bad :)

I actually prefer this. It doesn't look bad either IMO, apart from the PRI* macros that are always ugly, but most importantly you're explicitly using 64-bit types that work everywhere.

Quoted 19 lines

I believe the current casting is the least of the two evils.

Quoted 15 lines
Quoted 3 lines

Using the standard types in the V4L2 header would have avoided this issue. I wonder if there's anything to be gained by using the kernel types.

The kernel has defined __s64 as signed int int for a long time now, on all architectures, at least since

commit 0c79a8e29b5fcbcbfd611daf9d500cfad8370fcf

Author: Geert Uytterhoeven <[email protected]>
Date:   Thu Jan 23 15:53:43 2014 -0800

asm/types.h: Remove include/asm-generic/int-l64.h

which was merged in v3.14.

Quoted 7 lines
Quoted 4 lines

According to https://buildd.debian.org/status/package.php?p=yavta,
however, __s64 seems to be defined as long int on some platforms.

/me is puzzled

It does not help that __s64 is long long int and PRId64 is "d". I guess we can say that inttypes and kernel types do not play along?

I haven't encountered this issue in the past but I also haven't tried compiling for odd architectures.

Quoted 3 lines

I guess we need kerntypes.h with proper KPRId64 but that is probably out of scope here.

This could even depend on the compiler.

I wonder why we aren't using

	typedef uint64_t __u64;

in kernel UAPI headers instead. Including inttypes.h should not be an issue in 2023 anymore.

This problem is certainly wider in scope than yavta.

Signature · 3 lines
Regards,

Sakari Ailus
#7 lore raw

Hi Sakari

Quoted 85 lines · Sakari Ailus

Hi Ricardo,

Quoted 81 lines · Ricardo Ribalda

Hi Laurent, Hi Sakari

Quoted 70 lines · Laurent Pinchart
Quoted 68 lines · Sakari Ailus

Hi Ricardo,

Quoted 54 lines · Ricardo Ribalda

Hi Sakari

Quoted 19 lines · Sakari Ailus

Hi Ricardo,

Thanks for the patch.

Quoted 13 lines · Ricardo Ribalda

mipsel64el, ppc64el, ia64, ppc64, sparc64 and x32 have different lenghts for long long ints, which result in some compilation errors.

Lets add some castings to help the compiler deal with this.

We cannot use the Format macro constants ffrom inttypes because they seem to not be compatible with kernel (__u64 et al) types.

---
 yavta.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)
Quoted 13 lines

yavta.c static void video_query_menu(struct device *dev, · line 1316

Quoted 10 lines
yavta.c +1 -1
index d562863..bf54e4f 100644
@@ -1313,7 +1313,8 @@ static void video_query_menu(struct device *dev,
                      printf("  %u: %.32s%s\n", menu.index, menu.name,
                             menu.index == value ? " (*)" : "");
              else
-                     printf("  %u: %lld%s\n", menu.index, menu.value,
+                     printf("  %u: %lld%s\n", menu.index,

Could you instead use PRId64 for this? You can avoid casting to another type this way. Same for the other cases.

Already tried this:

(quoted diff) +1 -1
@@ -1313,7 +1313,7 @@ static void video_query_menu(struct device *dev,
                        printf("  %u: %.32s%s\n", menu.index, menu.name,
                               menu.index == value ? " (*)" : "");
                else
-                       printf("  %u: %lld%s\n", menu.index, menu.value,
+                       printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
                               menu.index == value ? " (*)" : "");
        };
 }

but gcc was not happy:

yavta.c: In function ‘video_query_menu’:
yavta.c:1316:11: warning: format ‘%ld’ expects argument of type ‘long int’, but argument 3 has type ‘__s64’ {aka ‘long long int’} [-Wformat=]

Quoted 8 lines
 1316 |    printf("  %u: %" PRId64 "%s\n", menu.index, menu.value,
      |           ^~~~~~~~~                            ~~~~~~~~~~
      |                                                    |
      |                                                    __s64 {aka

long long int}
In file included from yavta.c:26:
/usr/include/inttypes.h:57:34: note: format string is defined here
57 | # define PRId64 __PRI64_PREFIX "d"

I guess I should have expected this...

Quoted 2 lines
Quoted 2 lines

I'm not sure if it'd be prettier but another option is to use the PRI* macros and explicitly cast to a standard type.

I would like to avoid

Quoted 7 lines
Quoted 3 lines
  printf(" Hello %" PRId64 "\n", (uint64_t) value_s64);

That looks very bad :)

I actually prefer this. It doesn't look bad either IMO, apart from the PRI* macros that are always ugly, but most importantly you're explicitly using 64-bit types that work everywhere.

I am sending a v2, but it looks uglier (not that v1 was super beauty)

Quoted 23 lines
Quoted 23 lines

I believe the current casting is the least of the two evils.

Quoted 18 lines
Quoted 3 lines

Using the standard types in the V4L2 header would have avoided this issue. I wonder if there's anything to be gained by using the kernel types.

The kernel has defined __s64 as signed int int for a long time now, on all architectures, at least since

commit 0c79a8e29b5fcbcbfd611daf9d500cfad8370fcf

Author: Geert Uytterhoeven <[email protected]>
Date:   Thu Jan 23 15:53:43 2014 -0800

asm/types.h: Remove include/asm-generic/int-l64.h

which was merged in v3.14.

According to https://buildd.debian.org/status/package.php?p=yavta,
however, __s64 seems to be defined as long int on some platforms.

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

/me is puzzled

It does not help that __s64 is long long int and PRId64 is "d". I guess we can say that inttypes and kernel types do not play along?

I haven't encountered this issue in the past but I also haven't tried compiling for odd architectures.

Just to make it explicit

PRId64 == ld and _s64 == long long int

is a problem also for x86_64

Quoted 20 lines
Quoted 4 lines

I guess we need kerntypes.h with proper KPRId64 but that is probably out of scope here.

This could even depend on the compiler.

I wonder why we aren't using

        typedef uint64_t __u64;

in kernel UAPI headers instead. Including inttypes.h should not be an issue in 2023 anymore.

This problem is certainly wider in scope than yavta.

--
Regards,

Sakari Ailus

Signature · 1 line
Ricardo Ribalda