yepp.h

Go to the documentation of this file.

/***************************************************************************
 * $Id: yepp.h,v 1.6 2005/05/25 18:58:46 cowo Exp $
 ****************************************************************************/
/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef _YEPP_H_
#define _YEPP_H_

#ifdef _MSC_VER
#if _MSC_VER <= 1300
#error "Cannot compile with this version of M$C due to STL problems"
#endif
#endif //_MSC_VER

using namespace std;

#include <string>
#include <vector>
#include <list>
#include <stack>
#include <usb.h>

#include "exceptions.h"

#define USB_BLOCK_SIZE 0x40
#define DEVICE_INFO_RESULT_SIZE (USB_BLOCK_SIZE + 80)

#define YEPP_FLASH 0x4D

#define YEPP_MEDIA 0x53

#define YEPP_BULKBUFFER 0x240

class yeppTitleFrame    {
private:
    char start_frame:4;
    char title_frame_no:4;
    vector<char> characters;
public:
    yeppTitleFrame (const char *buffer);
    yeppTitleFrame (const yeppTitleFrame& source);
    yeppTitleFrame ();
    void getTitle (string& title);
    char *getTitle (void);
    friend ostream& operator<< (ostream& os, const yeppTitleFrame& f);
};

class yeppInfoFrame {
private:
    char trackID[13];
    int size;
public:
    yeppInfoFrame (const char *buffer);
    yeppInfoFrame (const yeppInfoFrame& source);
    yeppInfoFrame ();
    int getSize (void) {return size;};
    char* const getTrackID (void) {return trackID;};
    friend ostream& operator<< (ostream& os, const yeppInfoFrame& f);
};

class yeppTrack {
public:
    //~ vector<yeppTitleFrame> title_frames;
    list<yeppTitleFrame> title_frames;
    yeppInfoFrame info_frame;
    string title;

    yeppTrack () {};
    yeppTrack (const yeppTrack& source);
    int build (const char *buffer);
    int build_title (void);
    char* const getTrackID (void) {return info_frame.getTrackID();};

    friend ostream& operator<< (ostream& os, const yeppTrack& t);
};

class yeppPlaylist  {
public:
    vector<yeppTrack> tracks;
    yeppPlaylist () {};
    yeppPlaylist (const yeppPlaylist& source);
    int build (char *buffer, int buflen);
    int build (char *filename);

    int title_frame_no (char *buffer);
    friend ostream& operator<< (ostream& os, const yeppPlaylist& p);
};

class yepp  {
private:
    stack<string> error_stack;
    string device_info_string;
    int has_external_mem;
    int device_capacity;
    int device_space_available;
    int external_capacity;
    int external_space_available;
    char send_buffer[USB_BLOCK_SIZE*2];
    char recv_buffer[USB_BLOCK_SIZE];
    char bulk_buffer[YEPP_BULKBUFFER];
    char control_buffer[USB_BLOCK_SIZE];
    const unsigned int read_endpoint;
    const unsigned int write_endpoint;
    const unsigned char data_length;
    yeppPlaylist playlist;
    yeppPlaylist ext_playlist;

protected:
    struct usb_device *dev;
    struct usb_dev_handle *dev_handle;
    int usb_debug;
    int timeout;
    int retries;
    void last_error (string error);
    void last_error (const char *method, const char *format, ...);
    void clear_send_buffer (void);
    void clear_bulk_buffer (void);
    void clear_recv_buffer (void);
    void clear_control_buffer (void);
    void clear_buffers (void);
    void clear_halt (unsigned int endpoint) throw (YeppException, UsbException);
    void reset_ep (unsigned int endpoint) throw (YeppException, UsbException);
    int file_present (const char *filename, bool internal);
    void build_trackID (string& trackID, string filename);
public:
    const int vendor;
    const int product;

    yepp () :
        has_external_mem (-1),
        device_capacity (-1),
        device_space_available (-1),
        external_capacity (-1),
        external_space_available (-1),
        read_endpoint (0x82),
        write_endpoint (0x01),
        data_length (0x240),
        dev (NULL),
        dev_handle (NULL),
#ifdef DEBUG
        usb_debug (4),
#else
        usb_debug (0),
#endif //DEBUG
        timeout (5000),
        retries (2),
        vendor (0x4E8),
        product (0x5A00)
        {};
    ~yepp ();
    void init (struct usb_device *dev, int usb_debug = 0) throw(UsbException, YeppException);
    string last_error ();
    void control(int request, unsigned char lsb, unsigned char msb) throw (UsbException, YeppException);
    void recv(int request, unsigned char lsb, unsigned char msb, char *buffer, int size) throw (UsbException);
    void send(int request, unsigned char lsb, unsigned char msb, char *buffer, int size) throw (UsbException);

    void move_track (bool internal, unsigned int from, unsigned int to) throw (YeppException, UsbException) ;
    void get_device_info (void) throw (UsbException, YeppException);
    void get_device_info (string& dev_info) throw (UsbException, YeppException);
    void get_playlist (void) throw (YeppException, UsbException);
    void get_playlist (bool internal) throw (YeppException, UsbException);
    void get_playlist (yeppPlaylist& internal, yeppPlaylist& external) throw (YeppException, UsbException);
    void get_external_mem_info (void) throw (YeppException, UsbException);
    void get_device_capacity (int& internal, int& int_avail, int& ext, int& ext_avail);
    void delete_track (unsigned int trackno, bool internal=true) throw (YeppException, UsbException);

    void download (const char *filename, bool internal = true, void (*callback)(int, int) = NULL) throw (UsbException, YeppException);

    void format (bool internal = true) throw (YeppException, UsbException);

    void upload (unsigned int trackno, string filename = "", void (*callback)(int, int) = NULL) throw (YeppException, UsbException);

    void reset_read_ep (void) throw(UsbException, YeppException);
    void reset_write_ep (void) throw(UsbException, YeppException);
    friend ostream& operator<< (ostream& os, yepp& u);
};

#endif // _YEPP_H_

---