netmd++.h

Go to the documentation of this file.

/*
 * netmd++.h
 *
 * This file is part of netmd++, a library for accessing NetMD devices.
 *
 * It makes use of knowledge / code collected by Marc Britten and
 * Alexander Sulfrian for the Linux Minidisc project.
 *
 * Asivery helped to make this possible!
 * Sir68k discovered the Sony FW exploit!
 *
 * Copyright (C) 2023 Jo2003 (olenka.joerg@gmail.com)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#pragma once
#include <cstdint>
#include <sstream>
#include <vector>
#include <ctime>
#include <functional>
#include <mutex>
 
namespace netmd {

enum DiskFormat : uint8_t
{
    NETMD_DISKFORMAT_LP4       =   0,   
    NETMD_DISKFORMAT_LP2       =   2,   
    NETMD_DISKFORMAT_SP_MONO   =   4,   
    NETMD_DISKFORMAT_SP_STEREO =   6,   
    NO_ONTHEFLY_CONVERSION     = 0xf    
};

enum NetMdErr : int
{
    NETMDERR_NO_ERROR      =  0,  
    NETMDERR_USB           = -1,  
    NETMDERR_NOTREADY      = -2,  
    NETMDERR_TIMEOUT       = -3,  
    NETMDERR_CMD_FAILED    = -4,  
    NETMDERR_CMD_INVALID   = -5,  
    NETMDERR_PARAM         = -6,  
    NETMDERR_OTHER         = -7,  
    NETMDERR_NOT_SUPPORTED = -8,  
    NETMDERR_INTERIM       = -9,  
    NETMDERR_AGAIN         = -10, 
};

struct TrackTime
{
    int mMinutes;   
    int mSeconds;   
    int mTenthSecs; 
};

enum class TrackProtection : uint8_t
{
    UNPROTECTED = 0x00, 
    PROTECTED   = 0x03, 
    UNKNOWN     = 0xFF  
};

enum class AudioEncoding : uint8_t
{
    SP      = 0x90, 
    LP2     = 0x92, 
    LP4     = 0x93, 
    UNKNOWN = 0xff  
};

enum typelog
{
    DEBUG,      
    INFO,       
    WARN,       
    CRITICAL,   
    CAPTURE     
};

enum UTOCSector : uint16_t
{
    POS_ADDR,   
    HW_TITLES,  
    TSTAMPS,    
    FW_TITLES,  
    UNKNWN_1,   
    UNKNON_2,   
};

struct NetMdTime
{
    uint16_t hour;      
    uint8_t  minute;    
    uint8_t  second;    
    uint8_t  frame;     
};

struct DiscCapacity
{
    NetMdTime recorded;

    NetMdTime total;

    NetMdTime available;
};
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
struct Group
{
    int      mGid;      
    int16_t  mFirst;    
    int16_t  mLast;     
    std::string mName;  
};
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
enum HomebrewFeatures : uint32_t
{
    NOTHING     = 0x00, 
    SP_UPLOAD   = 0x01, 
    PCM_2_MONO  = 0x02, 
    PCM_SPEEDUP = 0x04, 
    USB_EXEC    = 0x08, 
};

using Groups = std::vector<Group>;

using NetMDByteVector = std::vector<uint8_t>;
 
//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
using EvtCallback = std::function<void(bool)>;
 
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& o, const TrackTime& tt);
 
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& o, const AudioEncoding& ae);
 
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& o, const TrackProtection& tp);
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
NetMDByteVector& operator+=(NetMDByteVector& a, const NetMDByteVector& b);

class CMDiscHeader;

class CNetMdDev;

class CNetMdSecure;

class CNetMdApi;

using  netmd_pp = CNetMdApi;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CNetMdApi
{
public:
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    CNetMdApi();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    ~CNetMdApi();
 
    //--------------------------------------------------------------------------
    //
    //--------------------------------------------------------------------------
    int initHotPlug();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int initDevice();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    std::string getDeviceName() const;
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    static void setLogLevel(int severity);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    static void setLogStream(std::ostream& os);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int trackCount();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int discFlags();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int eraseDisc();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int trackTime(int trackNo, TrackTime& trackTime);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int discTitle(std::string& title);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int setDiscTitle(const std::string& title);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int moveTrack(uint16_t from, uint16_t to);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int setGroupTitle(uint16_t group, const std::string& title);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int createGroup(const std::string& title, int first, int last);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int addTrackToGroup(int track, int group);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int delTrackFromGroup(int track, int group);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int deleteGroup(int group);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int deleteTrack(uint16_t track);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int trackBitRate(uint16_t track, AudioEncoding& encoding, uint8_t& channel);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int trackFlags(uint16_t track, TrackProtection& flags);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int trackTitle(uint16_t track, std::string& title);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    bool spUploadSupported();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    bool otfEncodeSupported();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    bool tocManipSupported();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    bool pcm2MonoSupported();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    bool nativeMonoUploadSupported();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    bool pcmSpeedupSupported();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int sendAudioFile(const std::string& filename, const std::string& title, DiskFormat otf);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int setTrackTitle(uint16_t trackNo, const std::string& title);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int discCapacity(DiscCapacity& dcap);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    Groups groups();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int prepareTOCManip();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    NetMDByteVector readUTOCSector(UTOCSector s);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int writeUTOCSector(UTOCSector s, const NetMDByteVector& data);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int finalizeTOC(bool reset = false, uint8_t resetWait = 15);
 
    //--------------------------------------------------------------------------
    //
    //
    //--------------------------------------------------------------------------
    int startHBSession(uint32_t features);
 
    //--------------------------------------------------------------------------
    //
    //
    //--------------------------------------------------------------------------
    void endHBSession(uint32_t features);
 
    //--------------------------------------------------------------------------
    //
    //--------------------------------------------------------------------------
    void registerForHotplugEvents(EvtCallback cb);
 
private:
    CMDiscHeader* mpDiscHeader;

    CNetMdDev* mpNetMd;

    CNetMdSecure* mpSecure;

    EvtCallback mHotplugCallback; 

    std::mutex mMutexHotplug;
};
 
namespace toc
{
    struct TOC;
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CNetMdTOC
{
public:
    struct DAOFragment
    {
        uint32_t mStart;    
        uint32_t mEnd;      
    };

    using DAOFragments = std::vector<DAOFragment>;
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    CNetMdTOC(int trackCount = 0, uint32_t lenInMs = 0, uint8_t* data = nullptr);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    ~CNetMdTOC();
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    void import(int trackCount = 0, uint32_t lenInMs = 0, uint8_t* data = nullptr);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int addTrack(uint8_t no, uint32_t lengthMs, const std::string& title, const std::time_t& tstamp, bool mono = false);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int setDiscTitle(const std::string& title);
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    int trackCount() const;
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    std::string discTitle() const;
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    std::string trackTitle(int trackNo) const;
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    std::string trackInfo(int trackNo) const;
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    std::string discInfo() const;
 
private:
    toc::TOC* mpToc;

    int       mTracksCount;

    uint32_t  mLengthInMs;

    uint32_t  mCurPos;

    int       mDAOTrack;

    uint32_t  mDAOGroups;

    DAOFragments mDAOFragments;
};
 
 
} // ~namespace