GNU bug report logs - #60214
[PATCH core-updates] gnu: webrtc-audio-processing: Update to 1.0.

Previous Next

Package: guix-patches;

Reported by: Adam Faiz <adam.faiz <at> disroot.org>

Date: Tue, 20 Dec 2022 08:21:02 UTC

Severity: normal

Tags: patch

Done: Maxim Cournoyer <maxim.cournoyer <at> gmail.com>

Bug is archived. No further changes may be made.

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 60214 in the body.
You can then email your comments to 60214 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

View this report as an mbox folder, status mbox, maintainer mbox


Report forwarded to guix-patches <at> gnu.org:
bug#60214; Package guix-patches. (Tue, 20 Dec 2022 08:21:02 GMT) Full text and rfc822 format available.

Acknowledgement sent to Adam Faiz <adam.faiz <at> disroot.org>:
New bug report received and forwarded. Copy sent to guix-patches <at> gnu.org. (Tue, 20 Dec 2022 08:21:02 GMT) Full text and rfc822 format available.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Adam Faiz <adam.faiz <at> disroot.org>
To: guix-patches <at> gnu.org
Cc: paren <at> disroot.org
Subject: [PATCH core-updates] gnu: webrtc-audio-processing: Update to 1.0.
Date: Tue, 20 Dec 2022 16:19:21 +0800
From 64c8e00eab770ca697c39feabfbc60927e4ccd57 Mon Sep 17 00:00:00 2001
From: AwesomeAdam54321 <adam.faiz <at> disroot.org>
Date: Tue, 20 Dec 2022 15:18:58 +0800
Subject: [PATCH] gnu: webrtc-audio-processing: Update to 1.0.

* gnu/packages/audio.scm (webrtc-audio-processing): Update to 1.0.
[source]: Add snippet that fixes building on riscv and powerpc 
architectures.
[arguments]: Remove patch-source phase.
[build-system]: Update to meson-build-system.
[inputs]: Add abseil-cpp as input.
* gnu/packages/patches/webrtc-audio-processing-big-endian.patch: Update 
to 1.0.
* 
gnu/packages/patches/webrtc-audio-processing-wav-header-big-endian.patch: 
New file.
* gnu/local.mk (dist_patch_DATA): Add it.
---
 gnu/local.mk                                  |   1 +
 gnu/packages/audio.scm                        |  77 +++---
 .../webrtc-audio-processing-big-endian.patch  | 249 ++++++++++++------
 ...dio-processing-wav-header-big-endian.patch | 152 +++++++++++
 4 files changed, 357 insertions(+), 122 deletions(-)
 create mode 100644 
gnu/packages/patches/webrtc-audio-processing-wav-header-big-endian.patch

diff --git a/gnu/local.mk b/gnu/local.mk
index af570125bd..4dfc03acce 100644
--- a/gnu/local.mk
+++ b/gnu/local.mk
@@ -1996,6 +1996,7 @@ dist_patch_DATA =						\
   %D%/packages/patches/warsow-qfusion-fix-bool-return-type.patch	\
   %D%/packages/patches/webkitgtk-adjust-bubblewrap-paths.patch	\
   %D%/packages/patches/webrtc-audio-processing-big-endian.patch	\
+ 
%D%/packages/patches/webrtc-audio-processing-wav-header-big-endian.patch	\

%D%/packages/patches/webrtc-for-telegram-desktop-fix-gcc12-cstdint.patch   \
   %D%/packages/patches/websocketpp-fix-for-cmake-3.15.patch	\
   %D%/packages/patches/widelands-add-missing-map-include.patch	\
diff --git a/gnu/packages/audio.scm b/gnu/packages/audio.scm
index e480ce9e58..140eeb2e1d 100644
--- a/gnu/packages/audio.scm
+++ b/gnu/packages/audio.scm
@@ -67,6 +67,7 @@ (define-module (gnu packages audio)
   #:use-module (gnu packages boost)
   #:use-module (gnu packages check)
   #:use-module (gnu packages compression)
+  #:use-module (gnu packages cpp)
   #:use-module (gnu packages curl)
   #:use-module (gnu packages dbm)
   #:use-module (gnu packages documentation)
@@ -249,55 +250,45 @@ (define-public wildmidi
 (define-public webrtc-audio-processing
   (package
     (name "webrtc-audio-processing")
-    (version "0.3.1")
+    (version "1.0")
     (source
      (origin
        (method url-fetch)
        (uri
         (string-append "http://freedesktop.org/software/pulseaudio/"
-                       name "/" name "-" version ".tar.xz"))
+                       name "/" name "-" version ".tar.gz"))
        (sha256
-        (base32 "1gsx7k77blfy171b6g3m0k0s0072v6jcawhmx1kjs9w5zlwdkzd0"))))
-    (build-system gnu-build-system)
-    (arguments
-     ;; TODO: Move this to a snippet/patch or remove with the upgrade 
to 1.0.
-     (if (or (target-riscv64?)
-             (target-powerpc?))
-       (list
-         #:phases
-         #~(modify-phases %standard-phases
-             (add-after 'unpack 'patch-source
-               (lambda* (#:key inputs #:allow-other-keys)
-                 (let ((patch-file
-                        #$(local-file
-                           (search-patch
-                             "webrtc-audio-processing-big-endian.patch"))))
-                   (invoke "patch" "--force" "-p1" "-i" patch-file)
-                   (substitute* "webrtc/typedefs.h"
-                     (("defined\\(__aarch64__\\)" all)
-                      (string-append
-                        ;; powerpc-linux
-                        "(defined(__PPC__) && __SIZEOF_SIZE_T__ == 4)\n"
-                        "#define WEBRTC_ARCH_32_BITS\n"
-                        "#define WEBRTC_ARCH_BIG_ENDIAN\n"
-                        ;; powerpc64-linux
-                        "#elif (defined(__PPC64__) && 
defined(_BIG_ENDIAN))\n"
-                        "#define WEBRTC_ARCH_64_BITS\n"
-                        "#define WEBRTC_ARCH_BIG_ENDIAN\n"
-                        ;; aarch64-linux
-                        "#elif " all
-                        ;; riscv64-linux
-                        " || (defined(__riscv) && __riscv_xlen == 64)"
-                        ;; powerpc64le-linux
-                        " || (defined(__PPC64__) && 
defined(_LITTLE_ENDIAN))"))))))))
-       '()))
-    (native-inputs
-     (if (or (target-riscv64?)
-             (target-powerpc?))
-       (list
-         (local-file (search-patch 
"webrtc-audio-processing-big-endian.patch"))
-         patch)
-       '()))
+        (base32 "0vwkw5xw8l37f5vbzbkipjsf03r7b8nnrfbfbhab8bkvf79306j4"))
+       (modules '((guix build utils)))
+       (snippet
+        #~(begin
+            ;; 
https://gitlab.freedesktop.org/pulseaudio/webrtc-audio-processing/-/issues/4
+            (substitute* "meson.build"
+              (("absl_flags_registry") "absl_flags_reflection"))
+            (substitute* "webrtc/rtc_base/system/arch.h"
+              (("defined\\(__aarch64__\\)" all)
+               (string-append
+                ;; powerpc-linux
+                "(defined(__PPC__) && __SIZEOF_SIZE_T__ == 4)\n"
+                "#define WEBRTC_ARCH_32_BITS\n"
+                "#define WEBRTC_ARCH_BIG_ENDIAN\n"
+                ;; powerpc64-linux
+                "#elif (defined(__PPC64__) && defined(_BIG_ENDIAN))\n"
+                "#define WEBRTC_ARCH_64_BITS\n"
+                "#define WEBRTC_ARCH_BIG_ENDIAN\n"
+                ;; aarch64-linux
+                "#elif " all
+                ;; riscv64-linux
+                " || (defined(__riscv) && __riscv_xlen == 64)"
+                ;; powerpc64le-linux
+                " || (defined(__PPC64__) && defined(_LITTLE_ENDIAN))")))))
+       (patches
+        (search-patches
+         "webrtc-audio-processing-big-endian.patch"
+         "webrtc-audio-processing-wav-header-big-endian.patch"))))
+    (build-system meson-build-system)
+    (inputs
+     (list abseil-cpp))
     (synopsis "WebRTC's Audio Processing Library")
     (description "WebRTC-Audio-Processing library based on Google's
 implementation of WebRTC.")
diff --git 
a/gnu/packages/patches/webrtc-audio-processing-big-endian.patch 
b/gnu/packages/patches/webrtc-audio-processing-big-endian.patch
index 78333fe7b7..c77fd87c1f 100644
--- a/gnu/packages/patches/webrtc-audio-processing-big-endian.patch
+++ b/gnu/packages/patches/webrtc-audio-processing-big-endian.patch
@@ -1,93 +1,184 @@
 https://bugs.freedesktop.org/show_bug.cgi?id=95738
-https://bugs.freedesktop.org/attachment.cgi?id=124025
+https://gitlab.freedesktop.org/pulseaudio/pulseaudio/-/issues/127
+https://github.com/desktop-app/tg_owt/commit/65f002e

-diff -up 
webrtc-audio-processing-0.2/webrtc/common_audio/wav_file.cc.than 
webrtc-audio-processing-0.2/webrtc/common_audio/wav_file.cc
---- webrtc-audio-processing-0.2/webrtc/common_audio/wav_file.cc.than 
2016-05-24 08:28:45.749940095 -0400
-+++ webrtc-audio-processing-0.2/webrtc/common_audio/wav_file.cc 
2016-05-24 08:50:30.361020010 -0400
-@@ -64,9 +64,6 @@ WavReader::~WavReader() {
+--- webrtc-audio-processing-1.0/webrtc/common_audio/wav_file.cc 
2020-11-28 03:30:53.000000000 +0800
++++ webrtc-audio-processing-1.0/webrtc/common_audio/wav_file.cc 
2022-12-20 12:54:22.058539694 +0800
+@@ -10,6 +10,7 @@
+
+ #include "common_audio/wav_file.h"
+
++#include <byteswap.h>
+ #include <errno.h>
+
+ #include <algorithm>
+@@ -34,6 +35,38 @@
+          format == WavFormat::kWavFormatIeeeFloat;
  }
-
- size_t WavReader::ReadSamples(size_t num_samples, int16_t* samples) {
+
++template <typename T>
++void TranslateEndianness(T* destination, const T* source, size_t length) {
++  static_assert(sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8,
++                "no converter, use integral types");
++  if (sizeof(T) == 2) {
++    const uint16_t* src = reinterpret_cast<const uint16_t*>(source);
++    uint16_t* dst = reinterpret_cast<uint16_t*>(destination);
++    for (size_t index = 0; index < length; index++) {
++      dst[index] = bswap_16(src[index]);
++    }
++  }
++  if (sizeof(T) == 4) {
++    const uint32_t* src = reinterpret_cast<const uint32_t*>(source);
++    uint32_t* dst = reinterpret_cast<uint32_t*>(destination);
++    for (size_t index = 0; index < length; index++) {
++      dst[index] = bswap_32(src[index]);
++    }
++  }
++  if (sizeof(T) == 8) {
++    const uint64_t* src = reinterpret_cast<const uint64_t*>(source);
++    uint64_t* dst = reinterpret_cast<uint64_t*>(destination);
++    for (size_t index = 0; index < length; index++) {
++      dst[index] = bswap_64(src[index]);
++    }
++  }
++}
++
++template <typename T>
++void TranslateEndianness(T* buffer, size_t length) {
++  TranslateEndianness(buffer, buffer, length);
++}
++
+ // Doesn't take ownership of the file handle and won't close it.
+ class WavHeaderFileReader : public WavHeaderReader {
+  public:
+@@ -90,10 +123,6 @@
+
+ size_t WavReader::ReadSamples(const size_t num_samples,
+                               int16_t* const samples) {
 -#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
 -#error "Need to convert samples to big-endian when reading from WAV file"
 -#endif
-   // There could be metadata after the audio; ensure we don't read it.
-   num_samples = std::min(rtc::checked_cast<uint32_t>(num_samples),
-                          num_samples_remaining_);
-@@ -76,6 +73,12 @@ size_t WavReader::ReadSamples(size_t num
-   RTC_CHECK(read == num_samples || feof(file_handle_));
-   RTC_CHECK_LE(read, num_samples_remaining_);
-   num_samples_remaining_ -= rtc::checked_cast<uint32_t>(read);
-+#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
-+  //convert to big-endian
-+  for(size_t idx = 0; idx < num_samples; idx++) {
-+    samples[idx] = (samples[idx]<<8) | (samples[idx]>>8);
-+  }
+-
+   size_t num_samples_left_to_read = num_samples;
+   size_t next_chunk_start = 0;
+   while (num_samples_left_to_read > 0 && num_unread_samples_ > 0) {
+@@ -105,6 +134,9 @@
+       num_bytes_read = file_.Read(samples_to_convert.data(),
+                                   chunk_size * 
sizeof(samples_to_convert[0]));
+       num_samples_read = num_bytes_read / sizeof(samples_to_convert[0]);
++#ifdef WEBRTC_ARCH_BIG_ENDIAN
++      TranslateEndianness(samples_to_convert.data(), num_samples_read);
++#endif
+
+       for (size_t j = 0; j < num_samples_read; ++j) {
+         samples[next_chunk_start + j] = FloatToS16(samples_to_convert[j]);
+@@ -114,6 +146,10 @@
+       num_bytes_read = file_.Read(&samples[next_chunk_start],
+                                   chunk_size * sizeof(samples[0]));
+       num_samples_read = num_bytes_read / sizeof(samples[0]);
++
++#ifdef WEBRTC_ARCH_BIG_ENDIAN
++      TranslateEndianness(&samples[next_chunk_start], num_samples_read);
 +#endif
-   return read;
+     }
+     RTC_CHECK(num_samples_read == 0 || (num_bytes_read % 
num_samples_read) == 0)
+         << "Corrupt file: file ended in the middle of a sample.";
+@@ -129,10 +165,6 @@
  }
-
-@@ -120,10 +123,17 @@ WavWriter::~WavWriter() {
-
+
+ size_t WavReader::ReadSamples(const size_t num_samples, float* const 
samples) {
+-#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
+-#error "Need to convert samples to big-endian when reading from WAV file"
+-#endif
+-
+   size_t num_samples_left_to_read = num_samples;
+   size_t next_chunk_start = 0;
+   while (num_samples_left_to_read > 0 && num_unread_samples_ > 0) {
+@@ -145,6 +177,9 @@
+       num_bytes_read = file_.Read(samples_to_convert.data(),
+                                   chunk_size * 
sizeof(samples_to_convert[0]));
+       num_samples_read = num_bytes_read / sizeof(samples_to_convert[0]);
++#ifdef WEBRTC_ARCH_BIG_ENDIAN
++      TranslateEndianness(samples_to_convert.data(), num_samples_read);
++#endif
+
+       for (size_t j = 0; j < num_samples_read; ++j) {
+         samples[next_chunk_start + j] =
+@@ -155,6 +190,9 @@
+       num_bytes_read = file_.Read(&samples[next_chunk_start],
+                                   chunk_size * sizeof(samples[0]));
+       num_samples_read = num_bytes_read / sizeof(samples[0]);
++#ifdef WEBRTC_ARCH_BIG_ENDIAN
++      TranslateEndianness(&samples[next_chunk_start], num_samples_read);
++#endif
+
+       for (size_t j = 0; j < num_samples_read; ++j) {
+         samples[next_chunk_start + j] =
+@@ -213,24 +251,32 @@
+ }
+
  void WavWriter::WriteSamples(const int16_t* samples, size_t 
num_samples) {
- #ifndef WEBRTC_ARCH_LITTLE_ENDIAN
+-#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
 -#error "Need to convert samples to little-endian when writing to WAV 
file"
 -#endif
-+  int16_t * le_samples = new int16_t[num_samples];
-+  for(size_t idx = 0; idx < num_samples; idx++) {
-+    le_samples[idx] = (samples[idx]<<8) | (samples[idx]>>8);
-+  }
-+  const size_t written =
-+      fwrite(le_samples, sizeof(*le_samples), num_samples, file_handle_);
-+  delete []le_samples;
+-
+   for (size_t i = 0; i < num_samples; i += kMaxChunksize) {
+     const size_t num_remaining_samples = num_samples - i;
+     const size_t num_samples_to_write =
+         std::min(kMaxChunksize, num_remaining_samples);
+
+     if (format_ == WavFormat::kWavFormatPcm) {
++#ifndef WEBRTC_ARCH_BIG_ENDIAN
+       RTC_CHECK(
+           file_.Write(&samples[i], num_samples_to_write * 
sizeof(samples[0])));
 +#else
-   const size_t written =
-       fwrite(samples, sizeof(*samples), num_samples, file_handle_);
++      std::array<int16_t, kMaxChunksize> converted_samples;
++      TranslateEndianness(converted_samples.data(), &samples[i],
++                          num_samples_to_write);
++      RTC_CHECK(
++          file_.Write(converted_samples.data(),
++                      num_samples_to_write * 
sizeof(converted_samples[0])));
++#endif
+     } else {
+       RTC_CHECK_EQ(format_, WavFormat::kWavFormatIeeeFloat);
+       std::array<float, kMaxChunksize> converted_samples;
+       for (size_t j = 0; j < num_samples_to_write; ++j) {
+         converted_samples[j] = S16ToFloat(samples[i + j]);
+       }
++#ifdef WEBRTC_ARCH_BIG_ENDIAN
++      TranslateEndianness(converted_samples.data(), num_samples_to_write);
 +#endif
-   RTC_CHECK_EQ(num_samples, written);
-   num_samples_ += static_cast<uint32_t>(written);
-   RTC_CHECK(written <= std::numeric_limits<uint32_t>::max() ||
-diff -up 
webrtc-audio-processing-0.2/webrtc/common_audio/wav_header.cc.than 
webrtc-audio-processing-0.2/webrtc/common_audio/wav_header.cc
---- webrtc-audio-processing-0.2/webrtc/common_audio/wav_header.cc.than 
2016-05-24 08:50:52.591379263 -0400
-+++ webrtc-audio-processing-0.2/webrtc/common_audio/wav_header.cc 
2016-05-24 08:52:08.552606848 -0400
-@@ -129,7 +129,39 @@ static inline std::string ReadFourCC(uin
-   return std::string(reinterpret_cast<char*>(&x), 4);
+       RTC_CHECK(
+           file_.Write(converted_samples.data(),
+                       num_samples_to_write * 
sizeof(converted_samples[0])));
+@@ -243,10 +289,6 @@
  }
- #else
--#error "Write be-to-le conversion functions"
-+static inline void WriteLE16(uint16_t* f, uint16_t x) {
-+  *f = ((x << 8) & 0xff00)  | ( ( x >> 8) & 0x00ff);
-+}
-+
-+static inline void WriteLE32(uint32_t* f, uint32_t x) {
-+    *f = ( (x & 0x000000ff) << 24 )
-+      | ((x & 0x0000ff00) << 8)
-+      | ((x & 0x00ff0000) >> 8)
-+      | ((x & 0xff000000) >> 24 );
-+}
-+
-+static inline void WriteFourCC(uint32_t* f, char a, char b, char c, 
char d) {
-+    *f = (static_cast<uint32_t>(a) << 24 )
-+      |  (static_cast<uint32_t>(b) << 16)
-+      |  (static_cast<uint32_t>(c) << 8)
-+      |  (static_cast<uint32_t>(d) );
-+}
-+
-+static inline uint16_t ReadLE16(uint16_t x) {
-+  return  (( x & 0x00ff) << 8 )| ((x & 0xff00)>>8);
-+}
-+
-+static inline uint32_t ReadLE32(uint32_t x) {
-+  return   ( (x & 0x000000ff) << 24 )
-+         | ( (x & 0x0000ff00) << 8 )
-+         | ( (x & 0x00ff0000) >> 8)
-+         | ( (x & 0xff000000) >> 24 );
-+}
-+
-+static inline std::string ReadFourCC(uint32_t x) {
-+  x = ReadLE32(x);
-+  return std::string(reinterpret_cast<char*>(&x), 4);
-+}
- #endif
-
- static inline uint32_t RiffChunkSize(uint32_t bytes_in_payload) {
+
+ void WavWriter::WriteSamples(const float* samples, size_t num_samples) {
+-#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
+-#error "Need to convert samples to little-endian when writing to WAV file"
+-#endif
+-
+   for (size_t i = 0; i < num_samples; i += kMaxChunksize) {
+     const size_t num_remaining_samples = num_samples - i;
+     const size_t num_samples_to_write =
+@@ -257,6 +299,9 @@
+       for (size_t j = 0; j < num_samples_to_write; ++j) {
+         converted_samples[j] = FloatS16ToS16(samples[i + j]);
+       }
++#ifdef WEBRTC_ARCH_BIG_ENDIAN
++      TranslateEndianness(converted_samples.data(), num_samples_to_write);
++#endif
+       RTC_CHECK(
+           file_.Write(converted_samples.data(),
+                       num_samples_to_write * 
sizeof(converted_samples[0])));
+@@ -266,6 +311,9 @@
+       for (size_t j = 0; j < num_samples_to_write; ++j) {
+         converted_samples[j] = FloatS16ToFloat(samples[i + j]);
+       }
++#ifdef WEBRTC_ARCH_BIG_ENDIAN
++      TranslateEndianness(converted_samples.data(), num_samples_to_write);
++#endif
+       RTC_CHECK(
+           file_.Write(converted_samples.data(),
+                       num_samples_to_write * 
sizeof(converted_samples[0])));
diff --git 
a/gnu/packages/patches/webrtc-audio-processing-wav-header-big-endian.patch 
b/gnu/packages/patches/webrtc-audio-processing-wav-header-big-endian.patch
new file mode 100644
index 0000000000..b25c2e364f
--- /dev/null
+++ 
b/gnu/packages/patches/webrtc-audio-processing-wav-header-big-endian.patch
@@ -0,0 +1,152 @@
+https://gitlab.freedesktop.org/pulseaudio/pulseaudio/-/issues/127
+https://github.com/desktop-app/tg_owt/commit/65f002e
+
+--- webrtc-audio-processing-1.0/webrtc/common_audio/wav_header.cc 
2020-11-28 03:30:53.000000000 +0800
++++ webrtc-audio-processing-1.0/webrtc/common_audio/wav_header.cc 
2022-12-19 20:28:31.511187824 +0800
+@@ -15,6 +15,8 @@
+
+ #include "common_audio/wav_header.h"
+
++#include <endian.h>
++
+ #include <cstring>
+ #include <limits>
+ #include <string>
+@@ -26,10 +28,6 @@
+ namespace webrtc {
+ namespace {
+
+-#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
+-#error "Code not working properly for big endian platforms."
+-#endif
+-
+ #pragma pack(2)
+ struct ChunkHeader {
+   uint32_t ID;
+@@ -80,6 +78,7 @@
+ // read audio samples.
+ #pragma pack(2)
+ struct WavHeaderPcm {
++  WavHeaderPcm() = default;
+   WavHeaderPcm(const WavHeaderPcm&) = default;
+   WavHeaderPcm& operator=(const WavHeaderPcm&) = default;
+   RiffHeader riff;
+@@ -95,6 +94,7 @@
+ // WAV implementation.
+ #pragma pack(2)
+ struct WavHeaderIeeeFloat {
++  WavHeaderIeeeFloat() = default;
+   WavHeaderIeeeFloat(const WavHeaderIeeeFloat&) = default;
+   WavHeaderIeeeFloat& operator=(const WavHeaderIeeeFloat&) = default;
+   RiffHeader riff;
+@@ -172,6 +172,8 @@
+     if (readable->Read(chunk_header, sizeof(*chunk_header)) !=
+         sizeof(*chunk_header))
+       return false;  // EOF.
++    chunk_header->Size = le32toh(chunk_header->Size);
++
+     if (ReadFourCC(chunk_header->ID) == sought_chunk_id)
+       return true;  // Sought chunk found.
+     // Ignore current chunk by skipping its payload.
+@@ -185,6 +187,13 @@
+   if (readable->Read(&(fmt_subchunk->AudioFormat), kFmtPcmSubchunkSize) !=
+       kFmtPcmSubchunkSize)
+     return false;
++  fmt_subchunk->AudioFormat = le16toh(fmt_subchunk->AudioFormat);
++  fmt_subchunk->NumChannels = le16toh(fmt_subchunk->NumChannels);
++  fmt_subchunk->SampleRate = le32toh(fmt_subchunk->SampleRate);
++  fmt_subchunk->ByteRate = le32toh(fmt_subchunk->ByteRate);
++  fmt_subchunk->BlockAlign = le16toh(fmt_subchunk->BlockAlign);
++  fmt_subchunk->BitsPerSample = le16toh(fmt_subchunk->BitsPerSample);
++
+   const uint32_t fmt_size = fmt_subchunk->header.Size;
+   if (fmt_size != kFmtPcmSubchunkSize) {
+     // There is an optional two-byte extension field permitted to be 
present
+@@ -212,19 +221,22 @@
+   auto header = rtc::MsanUninitialized<WavHeaderPcm>({});
+   const size_t bytes_in_payload = bytes_per_sample * num_samples;
+
+-  header.riff.header.ID = PackFourCC('R', 'I', 'F', 'F');
+-  header.riff.header.Size = RiffChunkSize(bytes_in_payload, *header_size);
+-  header.riff.Format = PackFourCC('W', 'A', 'V', 'E');
+-  header.fmt.header.ID = PackFourCC('f', 'm', 't', ' ');
+-  header.fmt.header.Size = kFmtPcmSubchunkSize;
+-  header.fmt.AudioFormat = 
MapWavFormatToHeaderField(WavFormat::kWavFormatPcm);
+-  header.fmt.NumChannels = static_cast<uint16_t>(num_channels);
+-  header.fmt.SampleRate = sample_rate;
+-  header.fmt.ByteRate = ByteRate(num_channels, sample_rate, 
bytes_per_sample);
+-  header.fmt.BlockAlign = BlockAlign(num_channels, bytes_per_sample);
+-  header.fmt.BitsPerSample = static_cast<uint16_t>(8 * bytes_per_sample);
+-  header.data.header.ID = PackFourCC('d', 'a', 't', 'a');
+-  header.data.header.Size = static_cast<uint32_t>(bytes_in_payload);
++  header.riff.header.ID = htole32(PackFourCC('R', 'I', 'F', 'F'));
++  header.riff.header.Size =
++      htole32(RiffChunkSize(bytes_in_payload, *header_size));
++  header.riff.Format = htole32(PackFourCC('W', 'A', 'V', 'E'));
++  header.fmt.header.ID = htole32(PackFourCC('f', 'm', 't', ' '));
++  header.fmt.header.Size = htole32(kFmtPcmSubchunkSize);
++  header.fmt.AudioFormat =
++      htole16(MapWavFormatToHeaderField(WavFormat::kWavFormatPcm));
++  header.fmt.NumChannels = htole16(num_channels);
++  header.fmt.SampleRate = htole32(sample_rate);
++  header.fmt.ByteRate =
++      htole32(ByteRate(num_channels, sample_rate, bytes_per_sample));
++  header.fmt.BlockAlign = htole16(BlockAlign(num_channels, 
bytes_per_sample));
++  header.fmt.BitsPerSample = htole16(8 * bytes_per_sample);
++  header.data.header.ID = htole32(PackFourCC('d', 'a', 't', 'a'));
++  header.data.header.Size = htole32(bytes_in_payload);
+
+   // Do an extra copy rather than writing everything to buf directly, 
since buf
+   // might not be correctly aligned.
+@@ -243,24 +255,26 @@
+   auto header = rtc::MsanUninitialized<WavHeaderIeeeFloat>({});
+   const size_t bytes_in_payload = bytes_per_sample * num_samples;
+
+-  header.riff.header.ID = PackFourCC('R', 'I', 'F', 'F');
+-  header.riff.header.Size = RiffChunkSize(bytes_in_payload, *header_size);
+-  header.riff.Format = PackFourCC('W', 'A', 'V', 'E');
+-  header.fmt.header.ID = PackFourCC('f', 'm', 't', ' ');
+-  header.fmt.header.Size = kFmtIeeeFloatSubchunkSize;
++  header.riff.header.ID = htole32(PackFourCC('R', 'I', 'F', 'F'));
++  header.riff.header.Size =
++      htole32(RiffChunkSize(bytes_in_payload, *header_size));
++  header.riff.Format = htole32(PackFourCC('W', 'A', 'V', 'E'));
++  header.fmt.header.ID = htole32(PackFourCC('f', 'm', 't', ' '));
++  header.fmt.header.Size = htole32(kFmtIeeeFloatSubchunkSize);
+   header.fmt.AudioFormat =
+-      MapWavFormatToHeaderField(WavFormat::kWavFormatIeeeFloat);
+-  header.fmt.NumChannels = static_cast<uint16_t>(num_channels);
+-  header.fmt.SampleRate = sample_rate;
+-  header.fmt.ByteRate = ByteRate(num_channels, sample_rate, 
bytes_per_sample);
+-  header.fmt.BlockAlign = BlockAlign(num_channels, bytes_per_sample);
+-  header.fmt.BitsPerSample = static_cast<uint16_t>(8 * bytes_per_sample);
+-  header.fmt.ExtensionSize = 0;
+-  header.fact.header.ID = PackFourCC('f', 'a', 'c', 't');
+-  header.fact.header.Size = 4;
+-  header.fact.SampleLength = static_cast<uint32_t>(num_channels * 
num_samples);
+-  header.data.header.ID = PackFourCC('d', 'a', 't', 'a');
+-  header.data.header.Size = static_cast<uint32_t>(bytes_in_payload);
++      htole16(MapWavFormatToHeaderField(WavFormat::kWavFormatIeeeFloat));
++  header.fmt.NumChannels = htole16(num_channels);
++  header.fmt.SampleRate = htole32(sample_rate);
++  header.fmt.ByteRate =
++      htole32(ByteRate(num_channels, sample_rate, bytes_per_sample));
++  header.fmt.BlockAlign = htole16(BlockAlign(num_channels, 
bytes_per_sample));
++  header.fmt.BitsPerSample = htole16(8 * bytes_per_sample);
++  header.fmt.ExtensionSize = htole16(0);
++  header.fact.header.ID = htole32(PackFourCC('f', 'a', 'c', 't'));
++  header.fact.header.Size = htole32(4);
++  header.fact.SampleLength = htole32(num_channels * num_samples);
++  header.data.header.ID = htole32(PackFourCC('d', 'a', 't', 'a'));
++  header.data.header.Size = htole32(bytes_in_payload);
+
+   // Do an extra copy rather than writing everything to buf directly, 
since buf
+   // might not be correctly aligned.
+@@ -389,6 +403,7 @@
+     return false;
+   if (ReadFourCC(header.riff.Format) != "WAVE")
+     return false;
++  header.riff.header.Size = le32toh(header.riff.header.Size);
+
+   // Find "fmt " and "data" chunks. While the official Wave file 
specification
+   // does not put requirements on the chunks order, it is uncommon to 
find the
-- 
2.38.1




Reply sent to Maxim Cournoyer <maxim.cournoyer <at> gmail.com>:
You have taken responsibility. (Mon, 22 Jan 2024 04:41:02 GMT) Full text and rfc822 format available.

Notification sent to Adam Faiz <adam.faiz <at> disroot.org>:
bug acknowledged by developer. (Mon, 22 Jan 2024 04:41:02 GMT) Full text and rfc822 format available.

Message #10 received at 60214-done <at> debbugs.gnu.org (full text, mbox):

From: Maxim Cournoyer <maxim.cournoyer <at> gmail.com>
To: Adam Faiz <adam.faiz <at> disroot.org>
Cc: paren <at> disroot.org, 60214-done <at> debbugs.gnu.org
Subject: Re: bug#60214: [PATCH core-updates] gnu: webrtc-audio-processing:
 Update to 1.0.
Date: Sun, 21 Jan 2024 23:39:55 -0500
Hi Adam,

Adam Faiz <adam.faiz <at> disroot.org> writes:

>  From 64c8e00eab770ca697c39feabfbc60927e4ccd57 Mon Sep 17 00:00:00 2001
> From: AwesomeAdam54321 <adam.faiz <at> disroot.org>
> Date: Tue, 20 Dec 2022 15:18:58 +0800
> Subject: [PATCH] gnu: webrtc-audio-processing: Update to 1.0.
>
> * gnu/packages/audio.scm (webrtc-audio-processing): Update to 1.0.
> [source]: Add snippet that fixes building on riscv and powerpc 
> architectures.
> [arguments]: Remove patch-source phase.
> [build-system]: Update to meson-build-system.
> [inputs]: Add abseil-cpp as input.
> * gnu/packages/patches/webrtc-audio-processing-big-endian.patch: Update 
> to 1.0.
> * 
> gnu/packages/patches/webrtc-audio-processing-wav-header-big-endian.patch: 
> New file.
> * gnu/local.mk (dist_patch_DATA): Add it.

Applied in 0720122bb7, with a follow-up in 42993ce9c4 to refresh it to
its version 1.3

-- 
Thanks,
Maxim




bug archived. Request was from Debbugs Internal Request <help-debbugs <at> gnu.org> to internal_control <at> debbugs.gnu.org. (Mon, 19 Feb 2024 12:24:07 GMT) Full text and rfc822 format available.

This bug report was last modified 37 days ago.

Previous Next


GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.