change options parameter impl

Author: tugrul

README.md

@@ -18,13 +18,15 @@ ffprobe.getFileInfo('sample.mp4').then(result => {
 
 ```
 
-passing in probesize and analyzeduration 
+## Passing options
+
+Available options are: probeSize, analyzeDuration
 
 ```javascript
 
 const ffprobe = require('@tugrul/ffprobe');
 
-ffprobe.getFileInfo({ filePath: 'sample.mp4', options: { probeSize: 1 * 1024 * 1024 * 1024, analyzeDuration: 1000 * 1000000 } }).then(result => {
+ffprobe.getFileInfo(sample.mp4, { probeSize: 1 * 1024 * 1024 * 1024, analyzeDuration: 1000 * 1000000 }).then(result => {
     console.log(result);
 });
 

index.d.ts

@@ -177,5 +177,10 @@ export interface Versions {
     readonly avutil: string;
 }
 
+export interface FileInfoOptions {
+    probeSize: number;
+    analyzeDuration: number;
+}
+
 export declare const versions: Versions;
-export declare function getFileInfo(filePath: string): Promise<AvFormatContext>;
+export declare function getFileInfo(filePath: string, options?: FileInfoOptions): Promise<AvFormatContext>;

src/avdictionary.h

@@ -0,0 +1,86 @@
+
+#pragma once
+
+extern "C" {
+    #include <libavutil/dict.h>
+}
+
+#include <string>
+
+namespace node_ffprobe {
+
+/**
+ * RAII wrapper for FFmpeg's AVDictionary
+ * Provides automatic memory management and convenient methods
+ * for dictionary operations.
+ */
+class AvDictionary {
+public:
+    // Default constructor creates an empty dictionary
+    AvDictionary() : m_dict(nullptr) {}
+
+    // Constructor from existing AVDictionary pointer (takes ownership)
+    explicit AvDictionary(AVDictionary* dict) : m_dict(dict) {}
+
+    // Move constructor
+    AvDictionary(AvDictionary&& other) noexcept : m_dict(other.m_dict) {
+        other.m_dict = nullptr;
+    }
+
+    // Move assignment operator
+    AvDictionary& operator=(AvDictionary&& other) noexcept {
+        if (this != &other) {
+            free();
+            m_dict = other.m_dict;
+            other.m_dict = nullptr;
+        }
+        return *this;
+    }
+
+    // Destructor automatically frees the dictionary
+    ~AvDictionary() {
+        free();
+    }
+
+    // Delete copy constructor and assignment operator
+    AvDictionary(const AvDictionary&) = delete;
+    AvDictionary& operator=(const AvDictionary&) = delete;
+
+    // Set a key-value pair in the dictionary
+    int set(const std::string& key, const std::string& value, int flags = 0) {
+        return av_dict_set(&m_dict, key.c_str(), value.c_str(), flags);
+    }
+
+    // Set a key with integer value in the dictionary
+    int set(const std::string& key, int64_t value, int flags = 0) {
+        return av_dict_set_int(&m_dict, key.c_str(), value, flags);
+    }
+
+    // Manually free the dictionary
+    void free() {
+        if (m_dict) {
+            av_dict_free(&m_dict);
+            m_dict = nullptr;
+        }
+    }
+
+    // Get the underlying AVDictionary pointer
+    AVDictionary* getBareInstance() const {
+        return m_dict;
+    }
+
+    // Allow implicit casting to AVDictionary** for use in FFmpeg functions
+    operator AVDictionary**() {
+        return &m_dict;
+    }
+
+    // Allow implicit casting to AVDictionary* for use in FFmpeg functions
+    operator AVDictionary*() const {
+        return m_dict;
+    }
+
+private:
+    AVDictionary* m_dict;
+};
+
+};

src/ffprobe.cc

@@ -21,6 +21,7 @@ extern "C" {
 #include "avchapter.h"
 #include "avprogram.h"
 #include "avstream.h"
+#include "avdictionary.h"
 
 
 namespace node_ffprobe {
@@ -32,46 +33,34 @@ Napi::Promise GetFileInfo(const Napi::CallbackInfo& info) {
 
     Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
 
-    std::string filePath;
-    int64_t probeSize = 0;
-    int64_t analyzeDuration = 0;
 
-    if (info[0].IsString()) {
-
-        filePath = info[0].As<Napi::String>();
+    if (!info[0].IsString()) {
+        deferred.Reject(Napi::TypeError::New(env, Napi::String::New(env,"filePath parameter should be a string value")).Value());
+        return deferred.Promise();
     }
-    else if (info[0].IsObject()) {
 
-        Napi::Object obj = info[0].As<Napi::Object>();
+    AvDictionary options;
 
-        if (!obj.Has("filePath") || !obj.Get("filePath").IsString()) {
-            deferred.Reject(Napi::TypeError::New(env, "Missing or invalid 'filePath' field").Value());
+    if (!info[1].IsUndefined()) {
+        if (!info[1].IsObject()) {
+            deferred.Reject(Napi::TypeError::New(env, Napi::String::New(env,"options can only be an object")).Value());
             return deferred.Promise();
         }
 
-        filePath = obj.Get("filePath").As<Napi::String>();
-
-        if (obj.Has("options") && obj.Get("options").IsObject()) {
-
-            Napi::Object opts = obj.Get("options").As<Napi::Object>();
+        Napi::Object opts = info[1].As<Napi::Object>();
 
-            if (opts.Has("probeSize") && opts.Get("probeSize").IsNumber()) {
-                probeSize = opts.Get("probeSize").As<Napi::Number>().Int64Value();
-            }
-
-            if (opts.Has("analyzeDuration") && opts.Get("analyzeDuration").IsNumber()) {
-                analyzeDuration = opts.Get("analyzeDuration").As<Napi::Number>().Int64Value();
-            }
+        if (opts.Has("probeSize") && opts.Get("probeSize").IsNumber()) {
+            options.set("probesize", opts.Get("probeSize").As<Napi::Number>().Int64Value());
         }
-    }
-    else {
 
-        deferred.Reject(Napi::TypeError::New(env, "Expected string or object as first argument").Value());
-        return deferred.Promise();
+        if (opts.Has("analyzeDuration") && opts.Get("analyzeDuration").IsNumber()) {
+            options.set("analyzeduration", opts.Get("analyzeDuration").As<Napi::Number>().Int64Value());
+        }
     }
 
+    std::string filePath = info[0].As<Napi::String>();
 
-    MediaInfoWorker* worker = new MediaInfoWorker(env, filePath, probeSize, analyzeDuration, std::move(deferred));
+    MediaInfoWorker* worker = new MediaInfoWorker(env, filePath, std::move(options), std::move(deferred));
 
     worker->Queue();
 

src/media-info-worker.cc

@@ -7,11 +7,10 @@ namespace node_ffprobe {
 AVFormatContext* MediaInfoWorker::sharedContext = nullptr;
 std::mutex MediaInfoWorker::sharedContextMutex;
 
-MediaInfoWorker::MediaInfoWorker(const Napi::Env& env, const std::string& fileName, const uint64_t probeSize, const uint64_t analyzeDuration, Napi::Promise::Deferred&& def): 
+MediaInfoWorker::MediaInfoWorker(const Napi::Env& env, const std::string& fileName, AvDictionary&& options, Napi::Promise::Deferred&& def): 
         Napi::AsyncWorker(env), 
-        fileName(fileName), 
-	probeSize(probeSize),
-        analyzeDuration(analyzeDuration),
+        fileName(fileName),
+        options(std::move(options)),
         deferred(std::move(def)) {}
 
 void MediaInfoWorker::Execute() {
@@ -23,21 +22,7 @@ void MediaInfoWorker::Execute() {
         return;
     }
 
-    AVDictionary* options = nullptr;
-
-    if (probeSize) {
-        av_dict_set_int(&options, "probesize", probeSize, 0);
-    }
-
-    if (analyzeDuration) {
-        av_dict_set_int(&options, "analyzeduration", analyzeDuration, 0);
-    }
-
-    int openStatus = avformat_open_input(&avFormatContext, fileName.c_str(), NULL, &options);
-
-    if (options) {
-        av_dict_free(&options);
-    }
+    int openStatus = avformat_open_input(&avFormatContext, fileName.c_str(), NULL, options);
 
     if (openStatus < 0) {
         Napi::AsyncWorker::SetError("filePath could not be opened");

src/media-info-worker.h

@@ -10,13 +10,14 @@ extern "C" {
 }
 
 #include "avformat-context.h"
+#include "avdictionary.h"
 
 namespace node_ffprobe {
 
 
 class MediaInfoWorker : public Napi::AsyncWorker {
 public:
-    MediaInfoWorker(const Napi::Env& env, const std::string& fileName, const uint64_t probeSize, const uint64_t analyzeDuration, Napi::Promise::Deferred&& def);
+    MediaInfoWorker(const Napi::Env& env, const std::string& fileName, AvDictionary&& options, Napi::Promise::Deferred&& def);
     void Execute() override;
     void OnOK() override;
     void OnError(const Napi::Error& error) override;
@@ -26,8 +27,7 @@ class MediaInfoWorker : public Napi::AsyncWorker {
 
 private:
     std::string fileName;
-    int64_t probeSize;
-    int64_t analyzeDuration;
+    AvDictionary options;
     Napi::Promise::Deferred deferred;
     static std::mutex sharedContextMutex;
     AVFormatContext* avFormatContext = nullptr;

test.js

@@ -53,6 +53,14 @@ describe('getFileInfo method', () => {
             await expect(getFileInfo('test-assets/test')).rejects.toThrow(msg);
         });
 
+        test('invalid type of options', async() => {
+
+            const msg = 'options can only be an object';
+        
+            await expect(getFileInfo('test-assets/test.mp4', 123)).rejects.toThrow(msg);
+            await expect(getFileInfo('test-assets/test.mp4', null)).rejects.toThrow(msg);
+            await expect(getFileInfo('test-assets/test.mp4', 'asdf')).rejects.toThrow(msg);
+        });
 
         // test('invalid media contents of a file on the filesystem', async() => {