[Update 1.2.3] Floating Lyrics Player and Editor Plugin

[Artem]

If you are willing to share a debug version, it would be much appreciated! 

https://disk.yandex.ru/d/rkuyG5XKbUOZ5Q

Can I also know what windows 10 version you are using(use "winver" command)?

22H2 (19045.6456)

[PaperFolding]

Video: https://skrinshoter.ru/vbpWx3anUDr

Thank you, the issue is caused because different regional decimal format we are using from our operating system. A bug fix release will be distributed shortly. Thank you for your time!

[PaperFolding]

https://disk.yandex.ru/d/rkuyG5XKbUOZ5Q

22H2 (19045.6456)

Sorry for bothering, I used this debug version of AIMP, but it neither pops me the exception dialog while exiting, nor there is any log file generated, you can see the video: https://drive.google.com/file/d/1D2zwg3vagMITw87QGeizwKBrkOOb0lCn/view?usp=sharing 
Is there any special steps I need to take to somehow log memory leak information?

Another question is about plugin API call, 
so do I have to call `.AddRef`/`.Release` explicitly for each `IUnknown` instance created/queried?
Please see this piece of code in my plugin, it is used to get menu item by ID, (please ignore C++/CLI ^ handles and grammars, they are only managed code), basically it calls `IAIMPServiceMenuManager::GetByID` under the hood, when  `IAIMPMenuItem` instance obtained successfully, I wrap it to my `AimpMenuItem` managed class instance and deliver it back to managed code to be used later.
At this time, I don't want the `IAIMPMenuItem` instance to be garbage collected or something, so I did not call `->Release` on it, in my option, calling `Release` on an `IUnknown` instance will destroy the instance, am I right or am I wrong? And must I call `.Release` at some point, like when application exiting? Can you try to explain to me? (This may sound stupid to you, apologize for my little knowledge about COM and delphi)

```cpp
#define RELEASE_IUNKNOWN(obj) if (obj != nullptr) { obj->Release(); obj = nullptr; }

    IMenuItem^ AimpServiceMenuManager::GetByID(String^ menuId) {
        IAIMPServiceMenuManager* service = nullptr;
        IAIMPString* _menuId = nullptr;
        try {
            service = this->GetService();
            IAIMPMenuItem* menu = nullptr;
            _menuId = AimpConverter::ToAimpString(menuId);
            if (service->GetByID(_menuId, &menu) == S_OK && menu != nullptr) {
                return gcnew AimpMenuItem(menu);  // wrap IAIMPMenuItem instance to my `AimpMenuItem` managed class and deliver it to managed code for use later
            }
            return nullptr;
        } finally {
            RELEASE_IUNKNOWN(_menuId);
            RELEASE_IUNKNOWN(service);
        }
    }
```

[DarkDrawKill]

Another question is about plugin API call,
so do I have to call `.AddRef`/`.Release` explicitly for each `IUnknown` instance created/queried?
Please see this piece of code in my plugin, it is used to get menu item by ID, (please ignore C++/CLI ^ handles and grammars, they are only managed code), basically it calls `IAIMPServiceMenuManager::GetByID` under the hood, when  `IAIMPMenuItem` instance obtained successfully, I wrap it to my `AimpMenuItem` managed class instance and deliver it back to managed code to be used later.
At this time, I don't want the `IAIMPMenuItem` instance to be garbage collected or something, so I did not call `->Release` on it, in my option, calling `Release` on an `IUnknown` instance will destroy the instance, am I right or am I wrong? And must I call `.Release` at some point, like when application exiting? Can you try to explain to me? (This may sound stupid to you, apologize for my little knowledge about COM and delphi)

When you call .Release method it decrements counter value. If value == 0 object destroys itself

Code: [Select]

    virtual DWORD __unknwncall Release(void)
    {
        DWORD reference_count = --counter;
        if (reference_count == 0)
            delete this;
        return reference_count;
    }

You must call .Release whenever u release a raw pointer

Code: [Select]

class MyObject: public IUnknown
{
    IUnknown* ptr; // a raw pointer

public:
    MyObject(IUnknown* ptr): ptr(ptr) {}
    virtual ~MyObject()
    {
        if (ptr) ptr->Release; // release raw pointer here
                                       // 'cause object doesnt own it anymore
    }
};

COM says u must call .AddRef only if u copy a raw pointer

Code: [Select]

    IUnknown* service = ...
    ...
    service->AddRef(); // u copy the raw pointer
                                // to MyObject object
    MyObject* obj = new MyObject(service);
    MyObject->AddRef(); // also increase the
                                    // counter of the created object
    ...

A common mistake is increasing parameter object's counter

Code: [Select]

    virtual HRESULT Initialize(IAIMPCore* core)
    {
        core->AddRef(); // Mistake - Memory leak
        ...
    }

Remember C++ is not C with classes so if u dont want to make memory leaks, implement RAII idiom (or use COM smart pointer in WIN32 header)

P.S. smart pointers dont work with IAIMPUIForm cause it shadows .Release() method to .Release(BOOL)
   

[PaperFolding]

DarkDrawKill

Thank you for explanation, and I've also read COM doc carefully. In my example, the pointer to `IAIMPMenuItem` indeed needs to call `Release` in the finally block. It's my fault to treat this way too simple.