feat: add groupBySeconds option

exzos28 · exzos28 · commit 0a3719e1fca2 · 2024-08-19T12:21:37.000+02:00
diff --git a/android/cpp-adapter.cpp b/android/cpp-adapter.cpp
@@ -4,15 +4,15 @@
 
 extern "C"
 JNIEXPORT jobjectArray JNICALL
-Java_com_audioanalyzer_AudioAnalyzerModule_analyzeAudio(JNIEnv *env, jclass obj, jstring filePath) {
+Java_com_audioanalyzer_AudioAnalyzerModule_analyzeAudio(JNIEnv *env, jclass obj, jstring filePath, jdouble groupBySeconds) {
 
     // Step 1: Convert Java string to C++ string
     const char *nativeFilePath = env->GetStringUTFChars(filePath, nullptr);
 
 
     // Step 2: Call the analyzeAudio function
     audioanalyzer::FFmpegException errorPtr = nullptr;
-    std::vector<audioanalyzer::AmplitudeData> amplitudeData = audioanalyzer::analyzeAudio(nativeFilePath, &errorPtr);
+    std::vector<audioanalyzer::AmplitudeData> amplitudeData = audioanalyzer::analyzeAudio(nativeFilePath, groupBySeconds, &errorPtr);
 
 
     if (errorPtr.getMessage()) {
diff --git a/android/src/main/java/com/audioanalyzer/AudioAnalyzerModule.java b/android/src/main/java/com/audioanalyzer/AudioAnalyzerModule.java
@@ -30,12 +30,12 @@ public String getName() {
     System.loadLibrary("cpp");
   }
 
-  private static native AmplitudeData[] analyzeAudio(String filepath);
+  private static native AmplitudeData[] analyzeAudio(String filepath, double groupBySeconds);
 
   @ReactMethod
-  public void analyzeAudio(String filepath, Promise promise) {
+  public void analyzeAudio(String filepath, double groupBySeconds, Promise promise) {
     try {
-      AmplitudeData[] analyze = analyzeAudio(filepath);
+      AmplitudeData[] analyze = analyzeAudio(filepath, groupBySeconds);
 
       WritableArray resultArray = new WritableNativeArray();
       for (AmplitudeData data : analyze) {
diff --git a/cpp/react-native-audio-analyzer.cpp b/cpp/react-native-audio-analyzer.cpp
@@ -14,38 +14,44 @@ const char* FFmpegException::getMessage() const noexcept {
     return message;
 }
 
-std::vector<AmplitudeData> analyzeAudio(const char *filename, FFmpegException *errorPtr) {
+std::vector<AmplitudeData> analyzeAudio(const char *filename, double groupBySeconds, FFmpegException *errorPtr) {
     std::vector<AmplitudeData> amplitudeData;
-    
+
+    // Проверка корректности groupBySeconds
+    if (groupBySeconds <= 0) {
+        *errorPtr = FFmpegException("groupBySeconds must be greater than 0");
+        return amplitudeData;
+    }
+
     // Allocate memory for the AVFormatContext
     AVFormatContext *formatContext = avformat_alloc_context();
     if (!formatContext) {
         *errorPtr = FFmpegException("Failed to allocate AVFormatContext");
         return amplitudeData;
     }
-    
+
     // Open the input file
     if (avformat_open_input(&formatContext, filename, nullptr, nullptr) != 0) {
         avformat_free_context(formatContext);
         *errorPtr = FFmpegException("Failed to open input file");
         return amplitudeData;
     }
-    
+
     // Find stream information
     if (avformat_find_stream_info(formatContext, nullptr) < 0) {
         avformat_close_input(&formatContext);
         *errorPtr = FFmpegException("Failed to find stream information");
         return amplitudeData;
     }
-    
+
     // Find the best audio stream
     int audioStreamIndex = av_find_best_stream(formatContext, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
     if (audioStreamIndex < 0) {
         avformat_close_input(&formatContext);
         *errorPtr = FFmpegException("Failed to find audio stream");
         return amplitudeData;
     }
-    
+
     // Get codec parameters and find the corresponding decoder
     AVCodecParameters *codecParameters = formatContext->streams[audioStreamIndex]->codecpar;
     const AVCodec *codec = avcodec_find_decoder(codecParameters->codec_id);
@@ -54,52 +60,53 @@ std::vector<AmplitudeData> analyzeAudio(const char *filename, FFmpegException *e
         *errorPtr = FFmpegException("Failed to find codec");
         return amplitudeData;
     }
-    
+
     // Allocate memory for the AVCodecContext
     AVCodecContext *codecContext = avcodec_alloc_context3(codec);
     if (!codecContext) {
         avformat_close_input(&formatContext);
         *errorPtr = FFmpegException("Failed to allocate AVCodecContext");
         return amplitudeData;
     }
-    
+
     // Set codec parameters
     if (avcodec_parameters_to_context(codecContext, codecParameters) < 0) {
         avformat_close_input(&formatContext);
         avcodec_free_context(&codecContext);
         *errorPtr = FFmpegException("Failed to set codec parameters");
         return amplitudeData;
     }
-    
+
     // Open the codec
     if (avcodec_open2(codecContext, codec, nullptr) < 0) {
         avformat_close_input(&formatContext);
         avcodec_free_context(&codecContext);
         *errorPtr = FFmpegException("Failed to open codec");
         return amplitudeData;
     }
-    
+
     // Allocate memory for AVPacket and AVFrame
     AVPacket packet;
     AVFrame *frame = av_frame_alloc();
-    
+
     // Initialize variables for audio analysis
     int sampleRate = codecContext->sample_rate;
     double accumulatedAmplitude = 0.0;
     long sampleCount = 0;
-    
+    double currentTimeGroup = 0.0;
+
     // Read frames from the input file
     while (av_read_frame(formatContext, &packet) >= 0) {
         if (packet.stream_index == audioStreamIndex) {
             // Send the packet to the codec
             if (avcodec_send_packet(codecContext, &packet) < 0) {
                 break;
             }
-            
+
             // Receive frames from the codec
             while (avcodec_receive_frame(codecContext, frame) >= 0) {
                 double timestampInSeconds = frame->pts * av_q2d(formatContext->streams[audioStreamIndex]->time_base);
-                
+
                 // Calculate amplitude for each sample in the frame
                 for (int i = 0; i < frame->nb_samples; i++) {
                     for (int ch = 0; ch < codecContext->ch_layout.nb_channels; ch++) {
@@ -108,36 +115,37 @@ std::vector<AmplitudeData> analyzeAudio(const char *filename, FFmpegException *e
                             if (i < frame->linesize[ch]) {
                                 accumulatedAmplitude += frame->data[ch][i];
                                 sampleCount++;
-                                
-                                // Calculate amplitude per second and store the data
-                                if (sampleCount >= sampleRate) {
-                                    double amplitudePerSecond = accumulatedAmplitude / sampleRate;
-                                    
+
+                                // Calculate amplitude for the specified groupBySeconds
+                                if ((timestampInSeconds - currentTimeGroup) >= groupBySeconds) {
+                                    double amplitudePerGroup = accumulatedAmplitude / sampleCount;
+
                                     AmplitudeData data{};
-                                    data.timeInSeconds = timestampInSeconds;
-                                    data.amplitude = amplitudePerSecond;
-                                    
+                                    data.timeInSeconds = currentTimeGroup;
+                                    data.amplitude = amplitudePerGroup;
+
                                     amplitudeData.push_back(data);
-                                    
+
                                     accumulatedAmplitude = 0.0;
                                     sampleCount = 0;
+                                    currentTimeGroup += groupBySeconds;
                                 }
                             }
                         }
                     }
                 }
             }
         }
-        
+
         // Release the packet
         av_packet_unref(&packet);
     }
-    
+
     // Clean up resources
     avformat_close_input(&formatContext);
     avcodec_free_context(&codecContext);
     av_frame_free(&frame);
-    
+
     return amplitudeData;
 }
 }
diff --git a/cpp/react-native-audio-analyzer.h b/cpp/react-native-audio-analyzer.h
@@ -21,7 +21,7 @@ namespace audioanalyzer {
         const char* getMessage() const noexcept;
     };
 
-    std::vector<AmplitudeData> analyzeAudio(const char *filename, FFmpegException *errorPtr);
+    std::vector<AmplitudeData> analyzeAudio(const char *filename, double groupBySeconds, FFmpegException *errorPtr);
 }
 
 #endif // AUDIOANALYZER_H
diff --git a/ios/AudioAnalyzer.h b/ios/AudioAnalyzer.h
@@ -13,6 +13,7 @@
 #endif
 
 - (void)analyzeAudio:(NSString *)filename
+            groupBySeconds:(nonnull NSNumber *)groupBySeconds
              resolver:(RCTPromiseResolveBlock)resolve
              rejecter:(RCTPromiseRejectBlock)reject;
 
diff --git a/ios/AudioAnalyzer.mm b/ios/AudioAnalyzer.mm
@@ -6,6 +6,7 @@ @implementation AudioAnalyzer
 RCT_EXPORT_MODULE()
 
 RCT_EXPORT_METHOD(analyzeAudio:(NSString *)filename
+                  groupBySeconds:(nonnull NSNumber *)groupBySeconds
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 {
@@ -14,7 +15,9 @@ @implementation AudioAnalyzer
 
         const char *cFilename = [filename UTF8String];
 
-        std::vector<audioanalyzer::AmplitudeData> result = audioanalyzer::analyzeAudio(cFilename, &ffmpegError);
+        double groupBySecondsValue = [groupBySeconds doubleValue];
+
+        std::vector<audioanalyzer::AmplitudeData> result = audioanalyzer::analyzeAudio(cFilename, groupBySecondsValue, &ffmpegError);
 
         if (ffmpegError.getMessage()) {
             NSString *errorMessage = [NSString stringWithUTF8String:ffmpegError.getMessage()];
diff --git a/src/index.tsx b/src/index.tsx
@@ -23,8 +23,11 @@ export type AmplitudeData = {
   // Other amplitude data
 };
 
-export function analyzeAudio(filepath: string): Promise<AmplitudeData[]> {
-  return AudioAnalyzer.analyzeAudio(filepath);
+export function analyzeAudio(
+  filepath: string,
+  groupBySeconds: number = 1
+): Promise<AmplitudeData[]> {
+  return AudioAnalyzer.analyzeAudio(filepath, groupBySeconds);
 }
 
 export * from './helpers';

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ namespace audioanalyzer {`
`21`	`21`	`const char* getMessage() const noexcept;`
`22`	`22`	`};`
`23`	`23`
`24`		`- std::vector<AmplitudeData> analyzeAudio(const char filename, FFmpegException errorPtr);`
	`24`	`+ std::vector<AmplitudeData> analyzeAudio(const char filename, double groupBySeconds, FFmpegException errorPtr);`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`#endif // AUDIOANALYZER_H`