react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

package/common/cpp/audioapi/dsp/VectorMath.cpp

@@ -25,6 +25,7 @@
 
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/dsp/VectorMath.h>
+#include <algorithm>
 
 #if defined(HAVE_ACCELERATE)
 #include <Accelerate/Accelerate.h>
@@ -47,8 +48,7 @@ void multiplyByScalar(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsmul(
-      inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
+  vDSP_vsmul(inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
 }
 
 void addScalar(
@@ -56,8 +56,7 @@ void addScalar(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsadd(
-      inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
+  vDSP_vsadd(inputVector, 1, &scalar, outputVector, 1, numberOfElementsToProcess);
 }
 
 void add(
@@ -65,14 +64,7 @@ void add(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vadd(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vadd(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 void subtract(
@@ -80,14 +72,7 @@ void subtract(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsub(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vsub(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 void multiply(
@@ -95,19 +80,10 @@ void multiply(
     const float *inputVector2,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vmul(
-      inputVector1,
-      1,
-      inputVector2,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vmul(inputVector1, 1, inputVector2, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
-float maximumMagnitude(
-    const float *inputVector,
-    size_t numberOfElementsToProcess) {
+float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess) {
   float maximumValue = 0;
   vDSP_maxmgv(inputVector, 1, &maximumValue, numberOfElementsToProcess);
   return maximumValue;
@@ -118,15 +94,7 @@ void multiplyByScalarThenAddToOutput(
     float scalar,
     float *outputVector,
     size_t numberOfElementsToProcess) {
-  vDSP_vsma(
-      inputVector,
-      1,
-      &scalar,
-      outputVector,
-      1,
-      outputVector,
-      1,
-      numberOfElementsToProcess);
+  vDSP_vsma(inputVector, 1, &scalar, outputVector, 1, outputVector, 1, numberOfElementsToProcess);
 }
 
 #else
@@ -508,15 +476,15 @@ void multiply(
   bool source2Aligned = is16ByteAligned(inputVector2);
   bool destAligned = is16ByteAligned(outputVector);
 
-#define SSE2_MULT(loadInstr, storeInstr)           \
-  while (outputVector < endP) {                    \
-    pSource1 = _mm_load_ps(inputVector1);          \
+#define SSE2_MULT(loadInstr, storeInstr) \
+  while (outputVector < endP) { \
+    pSource1 = _mm_load_ps(inputVector1); \
     pSource2 = _mm_##loadInstr##_ps(inputVector2); \
-    dest = _mm_mul_ps(pSource1, pSource2);         \
-    _mm_##storeInstr##_ps(outputVector, dest);     \
-    inputVector1 += 4;                             \
-    inputVector2 += 4;                             \
-    outputVector += 4;                             \
+    dest = _mm_mul_ps(pSource1, pSource2); \
+    _mm_##storeInstr##_ps(outputVector, dest); \
+    inputVector1 += 4; \
+    inputVector2 += 4; \
+    outputVector += 4; \
   }
 
   if (source2Aligned && destAligned) // Both aligned.
@@ -552,9 +520,7 @@ void multiply(
   }
 }
 
-float maximumMagnitude(
-    const float *inputVector,
-    size_t numberOfElementsToProcess) {
+float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess) {
   size_t n = numberOfElementsToProcess;
   float max = 0;
 
@@ -647,15 +613,15 @@ void multiplyByScalarThenAddToOutput(
 
   bool destAligned = is16ByteAligned(outputVector);
 
-#define SSE2_MULT_ADD(loadInstr, storeInstr)   \
-  while (outputVector < endP) {                \
-    pSource = _mm_load_ps(inputVector);        \
-    temp = _mm_mul_ps(pSource, mScale);        \
+#define SSE2_MULT_ADD(loadInstr, storeInstr) \
+  while (outputVector < endP) { \
+    pSource = _mm_load_ps(inputVector); \
+    temp = _mm_mul_ps(pSource, mScale); \
     dest = _mm_##loadInstr##_ps(outputVector); \
-    dest = _mm_add_ps(dest, temp);             \
+    dest = _mm_add_ps(dest, temp); \
     _mm_##storeInstr##_ps(outputVector, dest); \
-    inputVector += 4;                          \
-    outputVector += 4;                         \
+    inputVector += 4; \
+    outputVector += 4; \
   }
 
   if (destAligned)

package/common/cpp/audioapi/dsp/VectorMath.h

@@ -28,23 +28,50 @@
 // Defines the interface for several vector math functions whose implementation
 // will ideally be optimized.
 
-#include <cstddef>
 #include <algorithm>
 #include <cmath>
+#include <cstddef>
 
 namespace audioapi::dsp {
 
-void multiplyByScalarThenAddToOutput(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
+void multiplyByScalarThenAddToOutput(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
-void multiplyByScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
-void addScalar(const float *inputVector, float scalar, float *outputVector, size_t numberOfElementsToProcess);
-void add(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
-void subtract(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
-void multiply(const float *inputVector1, const float *inputVector2, float *outputVector, size_t numberOfElementsToProcess);
+void multiplyByScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void addScalar(
+    const float *inputVector,
+    float scalar,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void add(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void subtract(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
+void multiply(
+    const float *inputVector1,
+    const float *inputVector2,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
 // Finds the maximum magnitude of a float vector.
 float maximumMagnitude(const float *inputVector, size_t numberOfElementsToProcess);
 
-void linearToDecibels(const float *inputVector, float *outputVector, size_t numberOfElementsToProcess);
+void linearToDecibels(
+    const float *inputVector,
+    float *outputVector,
+    size_t numberOfElementsToProcess);
 
 } // namespace audioapi::dsp

package/common/cpp/audioapi/dsp/Windows.cpp

@@ -1,12 +1,10 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/Windows.h>
+#include <algorithm>
 
 namespace audioapi::dsp {
 
-void WindowFunction::forcePerfectReconstruction(
-    float *data,
-    int windowLength,
-    int interval) {
+void WindowFunction::forcePerfectReconstruction(float *data, int windowLength, int interval) {
   for (int i = 0; i < interval; ++i) {
     float sum2 = 0;
 
@@ -58,14 +56,11 @@ float Kaiser::bandwidthToBeta(float bandwidth, bool heuristicOptimal) {
 }
 
 void ApproximateConfinedGaussian::apply(float *data, int size) const {
-  auto offsetScale =
-      getGaussian(1.0f) / (getGaussian(3.0f) + getGaussian(-1.0f));
+  auto offsetScale = getGaussian(1.0f) / (getGaussian(3.0f) + getGaussian(-1.0f));
   auto norm = 1 / (getGaussian(1.0f) - 2 * offsetScale * getGaussian(2.0f));
   for (int i = 0; i < size; ++i) {
     auto r = static_cast<float>(2 * i + 1) / static_cast<float>(size) - 1.0f;
-    data[i] = norm *
-        (getGaussian(r) -
-         offsetScale * (getGaussian(r - 2) + getGaussian(r + 2)));
+    data[i] = norm * (getGaussian(r) - offsetScale * (getGaussian(r - 2) + getGaussian(r + 2)));
   }
 }
 

package/common/cpp/audioapi/dsp/Windows.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <cmath>
-#include <algorithm>
 
 namespace audioapi::dsp {
 
@@ -9,7 +8,7 @@ namespace audioapi::dsp {
 // https://personalpages.hs-kempten.de/~vollratj/InEl/pdf/Window%20function%20-%20Wikipedia.pdf
 class WindowFunction {
  public:
-  explicit WindowFunction(float amplitude = 1.0f): amplitude_(amplitude) {}
+  explicit WindowFunction(float amplitude = 1.0f) : amplitude_(amplitude) {}
 
   virtual void apply(float *data, int size) const = 0;
   // forces STFT perfect-reconstruction (WOLA) on an existing window, for a given STFT interval.
@@ -23,29 +22,30 @@ class WindowFunction {
 //https://en.wikipedia.org/wiki/Hann_function
 // https://www.sciencedirect.com/topics/engineering/hanning-window
 // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.hann.html#scipy.signal.windows.hann
-class Hann: public WindowFunction {
+class Hann : public WindowFunction {
  public:
-  explicit Hann(float amplitude = 1.0f): WindowFunction(amplitude) {}
+  explicit Hann(float amplitude = 1.0f) : WindowFunction(amplitude) {}
 
   void apply(float *data, int size) const override;
 };
 
 // https://www.sciencedirect.com/topics/engineering/blackman-window
 // https://docs.scipy.org/doc//scipy-1.2.3/reference/generated/scipy.signal.windows.blackman.html#scipy.signal.windows.blackman
-class Blackman: public WindowFunction {
+class Blackman : public WindowFunction {
  public:
-  explicit Blackman(float amplitude = 1.0f): WindowFunction(amplitude) {}
+  explicit Blackman(float amplitude = 1.0f) : WindowFunction(amplitude) {}
 
   void apply(float *data, int size) const override;
 };
 
-
 // https://en.wikipedia.org/wiki/Kaiser_window
-class Kaiser: public WindowFunction {
+class Kaiser : public WindowFunction {
  public:
-  explicit Kaiser(float beta, float amplitude = 1.0f): WindowFunction(amplitude), beta_(beta), invB0_(1.0f / bessel0(beta)) {}
+  explicit Kaiser(float beta, float amplitude = 1.0f)
+      : WindowFunction(amplitude), beta_(beta), invB0_(1.0f / bessel0(beta)) {}
 
-  static Kaiser withBandwidth(float bandwidth, bool heuristicOptimal = false, float amplitude = 1.0f) {
+  static Kaiser
+  withBandwidth(float bandwidth, bool heuristicOptimal = false, float amplitude = 1.0f) {
     return Kaiser(bandwidthToBeta(bandwidth, heuristicOptimal), amplitude);
   }
 
@@ -59,25 +59,26 @@ class Kaiser: public WindowFunction {
 
   // https://en.wikipedia.org/wiki/Bessel_function#Modified_Bessel_functions:_I%CE%B1,_K%CE%B1
   static inline float bessel0(float x) {
-      const double significanceLimit = 1e-4;
-      auto result = 0.0f;
-      auto term = 1.0f;
-      auto m = 1.0f;
-      while (term > significanceLimit) {
-          result += term;
-          ++m;
-          term *= (x * x) / (4 * m * m);
-      }
-
-      return result;
+    const double significanceLimit = 1e-4;
+    auto result = 0.0f;
+    auto term = 1.0f;
+    auto m = 1.0f;
+    while (term > significanceLimit) {
+      result += term;
+      ++m;
+      term *= (x * x) / (4 * m * m);
+    }
+
+    return result;
   }
   static float bandwidthToBeta(float bandwidth, bool heuristicOptimal = false);
 };
 
 // https://www.recordingblogs.com/wiki/gaussian-window
-class ApproximateConfinedGaussian: public WindowFunction {
+class ApproximateConfinedGaussian : public WindowFunction {
  public:
-  explicit ApproximateConfinedGaussian(float sigma, float amplitude = 1.0f): WindowFunction(amplitude), gaussianFactor_(0.0625f/(sigma*sigma)) {}
+  explicit ApproximateConfinedGaussian(float sigma, float amplitude = 1.0f)
+      : WindowFunction(amplitude), gaussianFactor_(0.0625f / (sigma * sigma)) {}
 
   static ApproximateConfinedGaussian withBandwidth(float bandwidth, float amplitude = 1.0f) {
     return ApproximateConfinedGaussian(bandwidthToSigma(bandwidth), amplitude);

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -1,5 +1,8 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace audioapi {
 
@@ -100,12 +103,9 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
         if (eventName.compare("audioReady") == 0) {
           auto bufferIt = body.find("buffer");
           if (bufferIt != body.end()) {
-            auto bufferHostObject =
-                std::static_pointer_cast<AudioBufferHostObject>(
-                    std::get<std::shared_ptr<jsi::HostObject>>(
-                        bufferIt->second));
-            eventObject =
-                createEventObject(body, bufferHostObject->getSizeInBytes());
+            auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
+                std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
+            eventObject = createEventObject(body, bufferHostObject->getSizeInBytes());
           }
         } else {
           eventObject = createEventObject(body);
@@ -117,8 +117,7 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
         throw;
       } catch (...) {
         printf(
-            "Unknown exception occurred while invoking handler for event: %s\n",
-            eventName.c_str());
+            "Unknown exception occurred while invoking handler for event: %s\n", eventName.c_str());
       }
     }
   });
@@ -168,11 +167,9 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
       if (eventName.compare("audioReady") == 0) {
         auto bufferIt = body.find("buffer");
         if (bufferIt != body.end()) {
-          auto bufferHostObject =
-              std::static_pointer_cast<AudioBufferHostObject>(
-                  std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
-          eventObject =
-              createEventObject(body, bufferHostObject->getSizeInBytes());
+          auto bufferHostObject = std::static_pointer_cast<AudioBufferHostObject>(
+              std::get<std::shared_ptr<jsi::HostObject>>(bufferIt->second));
+          eventObject = createEventObject(body, bufferHostObject->getSizeInBytes());
         }
       } else {
         eventObject = createEventObject(body);
@@ -184,8 +181,7 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
       throw;
     } catch (...) {
       printf(
-          "Unknown exception occurred while invoking handler for event: %s\n",
-          eventName.c_str());
+          "Unknown exception occurred while invoking handler for event: %s\n", eventName.c_str());
     }
   });
 }
@@ -208,8 +204,7 @@ jsi::Object AudioEventHandlerRegistry::createEventObject(
       eventObject.setProperty(*runtime_, name, std::get<bool>(value));
     } else if (std::holds_alternative<std::string>(value)) {
       eventObject.setProperty(*runtime_, name, std::get<std::string>(value));
-    } else if (std::holds_alternative<std::shared_ptr<jsi::HostObject>>(
-                   value)) {
+    } else if (std::holds_alternative<std::shared_ptr<jsi::HostObject>>(value)) {
       auto hostObject = jsi::Object::createFromHostObject(
           *runtime_, std::get<std::shared_ptr<jsi::HostObject>>(value));
       eventObject.setProperty(*runtime_, name, hostObject);

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -1,69 +1,74 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
-#include <memory>
-#include <unordered_map>
+#include <jsi/jsi.h>
 #include <array>
+#include <atomic>
+#include <memory>
 #include <string>
+#include <unordered_map>
 #include <variant>
-#include <atomic>
 
 namespace audioapi {
 using namespace facebook;
 
-using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
+using EventValue =
+    std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
 
 class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
  public:
   explicit AudioEventHandlerRegistry(
       jsi::Runtime *runtime,
       const std::shared_ptr<react::CallInvoker> &callInvoker);
-  ~AudioEventHandlerRegistry();
+  ~AudioEventHandlerRegistry() override;
 
-  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler) override;
+  uint64_t registerHandler(
+      const std::string &eventName,
+      const std::shared_ptr<jsi::Function> &handler) override;
   void unregisterHandler(const std::string &eventName, uint64_t listenerId) override;
 
-  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) override;
-  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) override;
+  void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      const std::unordered_map<std::string, EventValue> &body) override;
+  void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      uint64_t listenerId,
+      const std::unordered_map<std::string, EventValue> &body) override;
 
  private:
-    std::atomic<uint64_t> listenerIdCounter_{1}; // Atomic counter for listener IDs
+  std::atomic<uint64_t> listenerIdCounter_{1}; // Atomic counter for listener IDs
 
-    std::shared_ptr<react::CallInvoker> callInvoker_;
-    jsi::Runtime *runtime_;
-    std::unordered_map<std::string, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>> eventHandlers_;
+  std::shared_ptr<react::CallInvoker> callInvoker_;
+  jsi::Runtime *runtime_;
+  std::unordered_map<std::string, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>>
+      eventHandlers_;
 
-    static constexpr std::array<std::string_view, 15> SYSTEM_EVENT_NAMES = {
-        "remotePlay",
-        "remotePause",
-        "remoteStop",
-        "remoteTogglePlayPause",
-        "remoteChangePlaybackRate",
-        "remoteNextTrack",
-        "remotePreviousTrack",
-        "remoteSkipForward",
-        "remoteSkipBackward",
-        "remoteSeekForward",
-        "remoteSeekBackward",
-        "remoteChangePlaybackPosition",
-        "routeChange",
-        "interruption",
-        "volumeChange",
-    };
+  static constexpr std::array<std::string_view, 15> SYSTEM_EVENT_NAMES = {
+      "remotePlay",
+      "remotePause",
+      "remoteStop",
+      "remoteTogglePlayPause",
+      "remoteChangePlaybackRate",
+      "remoteNextTrack",
+      "remotePreviousTrack",
+      "remoteSkipForward",
+      "remoteSkipBackward",
+      "remoteSeekForward",
+      "remoteSeekBackward",
+      "remoteChangePlaybackPosition",
+      "routeChange",
+      "interruption",
+      "volumeChange",
+  };
 
-    static constexpr std::array<std::string_view, 6> AUDIO_API_EVENT_NAMES = {
-      "ended",
-      "loopEnded",
-      "audioReady",
-      "positionChanged",
-      "audioError",
-      "systemStateChanged"
-    };
+  static constexpr std::array<std::string_view, 6> AUDIO_API_EVENT_NAMES =
+      {"ended", "loopEnded", "audioReady", "positionChanged", "audioError", "systemStateChanged"};
 
-    jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
-    jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body, size_t memoryPressure);
+  jsi::Object createEventObject(const std::unordered_map<std::string, EventValue> &body);
+  jsi::Object createEventObject(
+      const std::unordered_map<std::string, EventValue> &body,
+      size_t memoryPressure);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/events/IAudioEventHandlerRegistry.h

@@ -1,25 +1,33 @@
 #pragma once
 
-#include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
 #include <unordered_map>
 #include <variant>
-#include <string>
-#include <memory>
 
 namespace audioapi {
 
-using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<facebook::jsi::HostObject>>;
+using EventValue =
+    std::variant<int, float, double, std::string, bool, std::shared_ptr<facebook::jsi::HostObject>>;
 
 class IAudioEventHandlerRegistry {
  public:
   virtual ~IAudioEventHandlerRegistry() = default;
 
-  virtual uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler) = 0;
+  virtual uint64_t registerHandler(
+      const std::string &eventName,
+      const std::shared_ptr<facebook::jsi::Function> &handler) = 0;
   virtual void unregisterHandler(const std::string &eventName, uint64_t listenerId) = 0;
 
-  virtual void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) = 0;
-  virtual void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) = 0;
+  virtual void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      const std::unordered_map<std::string, EventValue> &body) = 0;
+  virtual void invokeHandlerWithEventBody(
+      const std::string &eventName,
+      uint64_t listenerId,
+      const std::unordered_map<std::string, EventValue> &body) = 0;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/external/ffmpeg_include/libavcodec/avcodec.h

@@ -225,7 +225,7 @@ typedef struct RcOverride{
 #define AV_CODEC_FLAG_QPEL            (1 <<  4)
 /**
  * Request the encoder to output reconstructed frames, i.e.\ frames that would
- * be produced by decoding the encoded bistream. These frames may be retrieved
+ * be produced by decoding the encoded bitstream. These frames may be retrieved
  * by calling avcodec_receive_frame() immediately after a successful call to
  * avcodec_receive_packet().
  *
@@ -436,7 +436,7 @@ typedef struct AVCodecContext {
     const AVClass *av_class;
     int log_level_offset;
 
-    enum AVMediaTypeFFMPEG codec_type; /* see AVMEDIA_TYPE_xxx */
+    enum AVMediaTypeFFmpeg codec_type; /* see AVMEDIA_TYPE_xxx */
     const struct AVCodec  *codec;
     enum AVCodecID     codec_id; /* see AV_CODEC_ID_xxx */
 
@@ -1946,7 +1946,7 @@ typedef struct AVHWAccel {
      *
      * See AVMEDIA_TYPE_xxx
      */
-    enum AVMediaTypeFFMPEG type;
+    enum AVMediaTypeFFmpeg type;
 
     /**
      * Codec implemented by the hardware accelerator.
@@ -2900,7 +2900,7 @@ int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
  *
  * @note for encoders, this function will only do something if the encoder
  * declares support for AV_CODEC_CAP_ENCODER_FLUSH. When called, the encoder
- * will drain any remaining packets, and can then be re-used for a different
+ * will drain any remaining packets, and can then be reused for a different
  * stream (as opposed to sending a null frame which will leave the encoder
  * in a permanent EOF state after draining). This can be desirable if the
  * cost of tearing down and replacing the encoder instance is high.

package/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec.h

@@ -182,7 +182,7 @@ typedef struct AVCodec {
      * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
      */
     const char *long_name;
-    enum AVMediaTypeFFMPEG type;
+    enum AVMediaTypeFFmpeg type;
     enum AVCodecID id;
     /**
      * Codec capabilities.

package/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_desc.h

@@ -37,7 +37,7 @@
  */
 typedef struct AVCodecDescriptor {
     enum AVCodecID     id;
-    enum AVMediaTypeFFMPEG type;
+    enum AVMediaTypeFFmpeg type;
     /**
      * Name of the codec described by this descriptor. It is non-empty and
      * unique for each codec descriptor. It should contain alphanumeric

package/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_id.h

@@ -330,6 +330,7 @@ enum AVCodecID {
     AV_CODEC_ID_RV60,
     AV_CODEC_ID_JPEGXL_ANIM,
     AV_CODEC_ID_APV,
+    AV_CODEC_ID_PRORES_RAW,
 
     /* various PCM "codecs" */
     AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
@@ -602,6 +603,7 @@ enum AVCodecID {
     AV_CODEC_ID_BIN_DATA,
     AV_CODEC_ID_SMPTE_2038,
     AV_CODEC_ID_LCEVC,
+    AV_CODEC_ID_SMPTE_436M_ANC,
 
 
     AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
@@ -627,7 +629,7 @@ enum AVCodecID {
 /**
  * Get the type of the given codec.
  */
-enum AVMediaTypeFFMPEG avcodec_get_type(enum AVCodecID codec_id);
+enum AVMediaTypeFFmpeg avcodec_get_type(enum AVCodecID codec_id);
 
 /**
  * Get the name of a codec.

package/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_par.h

@@ -48,7 +48,7 @@ typedef struct AVCodecParameters {
     /**
      * General type of the encoded data.
      */
-    enum AVMediaTypeFFMPEG codec_type;
+    enum AVMediaTypeFFmpeg codec_type;
     /**
      * Specific type of the encoded data (the codec used).
      */
@@ -148,7 +148,7 @@ typedef struct AVCodecParameters {
      * durations. Should be set to { 0, 1 } when some frames have differing
      * durations or if the value is not known.
      *
-     * @note This field correponds to values that are stored in codec-level
+     * @note This field corresponds to values that are stored in codec-level
      * headers and is typically overridden by container/transport-layer
      * timestamps, when available. It should thus be used only as a last resort,
      * when no higher-level timing information is available.