Skip to: Content | Navigation | Footer

PMPlib API

[PMPlib Homepage]

Overview:

• Main page
• Modules
• Files

Global Namespace:

• All
• Functions
• Enumeration Constants
• Typedefs
• Preprocessor Definitions

Structs and Classes:

• Structs and Classes
• All members
• Fields/Members
• Functions/Methods
• Typedefs

pmp.h

Go to the documentation of this file.

/*
 *      Digital Media Player library.
 *
 *      Copyright (c) 2005-2007 Naoaki Okazaki
 *
 * 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 St, Fifth Floor, Boston, MA  02110-1301 USA
 *
 */

/* $Id: pmp.h 392 2007-02-23 09:37:33Z nyaochi $ */

#ifndef __PMP_H__
#define __PMP_H__

#include <pmplib/os_types.h>

#ifdef  PMP_EXPORTS
#define PMPAPI  __declspec(dllexport)
#else
#define PMPAPI
#endif/*PMP_EXPORTS*/

#ifdef  __cplusplus
extern "C" {
#endif/*__cplusplus*/


/*
 * Forward structure declarations.
 */
struct tag_pmp_t;
typedef struct tag_pmp_t pmp_t;

struct tag_pmp_music_t;
typedef struct tag_pmp_music_t pmp_music_t;

enum {
        PMP_SUCCESS = 0,
        PMPERR_ERROR = 0x80000000,
        PMPERR_DEVICENOTFOUND,
        PMPERR_INSUFFICIENTMEMORY,
        PMPERR_NOTIMPLIMENTED,
        PMPERR_ENTRYNOTFOUND,
        PMPERR_INCONSISTENCY,
        PMPERR_OPENFORREAD,
        PMPERR_OPENFORWRITE,
        PMPERR_READ,
        PMPERR_WRITE,
};

enum {
        PMPOF_MUSIC_DB_READ             = 0x0001,
        PMPOF_MUSIC_DB_WRITE    = 0x0002,
        PMPOF_MUSIC_PL_READ             = 0x0004,
        PMPOF_MUSIC_PL_WRITE    = 0x0008,
};

#define PMPFOURCC(a, b, c, d)   \
        ((uint32_t)(a) << 24 | (uint32_t)(b) << 16 | (uint32_t)(c) << 8 | (uint32_t)(d))

#define PMPCODEC_NONE                   PMPFOURCC(' ',' ',' ',' ')

#define PMPCODEC_MPEGLAYER3             PMPFOURCC('M','P','A','3')

#define PMPCODEC_WMA                    PMPFOURCC('W','M','A',' ')

#define PMPCODEC_VORBIS                 PMPFOURCC('O','g','g','V')

#define PMPCODEC_WAV                    PMPFOURCC('W','A','V','E')

enum {
        PMPF_NONE =                     0x0000,
        PMPMF_SUPPORT =         0x0001,
        PMPMF_RECURSIVE =       0x0002, 
        PMPPF_SUPPORT =         0x0010,
        PMPPF_RECURSIVE =       0x0020,
};


#define PMP_DECLSIZE    (128)

#define PMP_DECLUNAVAIL ("***")

typedef struct {
        char    id[PMP_DECLSIZE];
        char    manufacturer[PMP_DECLSIZE];
        char    name[PMP_DECLSIZE];
        char    mode[PMP_DECLSIZE];
        char    language[PMP_DECLSIZE];
        char    version[PMP_DECLSIZE];
        char    min_version[PMP_DECLSIZE];
        char    max_version[PMP_DECLSIZE];
} pmp_device_description_t;

typedef struct {
        ucs2char_t              path_to_root[MAX_PATH];
        ucs2char_t              path_to_system[MAX_PATH];
        ucs2char_t              path_to_music[MAX_PATH];
        ucs2char_t              path_to_playlist[MAX_PATH];

        uint32_t                music_flag;
        uint32_t                playlist_flag;

        uint32_t                num_audio_codecs;
        uint32_t*               audio_codecs;

        uint32_t                num_audio_extensions;
        ucs2char_t**    audio_extensions;

        const pmp_device_description_t  decl;
} pmp_device_information_t;

struct tag_pmp_t {
        void* instance;

        uint32_t ref_count;

        uint32_t flag;

        pmp_device_information_t info;

        pmp_music_t* music;

        uint32_t (*add_ref)(pmp_t* pmp);

        uint32_t (*release)(pmp_t* pmp);

        result_t (*open)(pmp_t* pmp, uint32_t flag);

        result_t (*close)(pmp_t* pmp);
};

struct tag_pmp_music_record_t {
        ucs2char_t              *filename;

        ucs2char_t              *title;

        ucs2char_t              *artist;

        ucs2char_t              *composer;

        ucs2char_t              *album;

        ucs2char_t              *genre;

        ucs2char_t              *date;

        uint32_t                codec;

        uint32_t                codec_version;

        uint8_t                 is_vbr;

        uint32_t                track_number;

        uint32_t                total_tracks;

        uint32_t                disc_number;

        uint32_t                total_discs;

        uint32_t                sample_rate;

        uint32_t                bitrate;

        uint32_t                duration;

        uint64_t                num_samples;

        uint32_t                filesize;

        uint32_t                ts_update;

        uint32_t                rating;

        uint32_t                play_count;

        uint32_t                ts_playback;

        uint32_t                ts_import;
};

typedef struct tag_pmp_music_record_t pmp_music_record_t;

typedef struct {
        ucs2char_t *name;

        int num_entries;

        ucs2char_t **entries;
} pmp_playlist_t;

struct tag_pmp_music_t {
        void* instance;

        pmp_t* pmp;

        result_t (*set_records)(pmp_music_t* music, const pmp_music_record_t* records, uint32_t num_records);

        result_t (*get_records)(pmp_music_t* music, pmp_music_record_t* records, uint32_t* num_records);

        result_t (*set_playlists)(pmp_music_t* music, const pmp_playlist_t* playlists, uint32_t num_playlists);

        result_t (*get_playlists)(pmp_music_t* music, pmp_playlist_t* playlists, uint32_t* num_playlists);

        result_t (*dump)(pmp_music_t* music, FILE *fp, int flag);
};

PMPAPI void pmplib_record_init(pmp_music_record_t* record);

PMPAPI void pmplib_record_finish(pmp_music_record_t* record);

PMPAPI result_t pmplib_record_clone(pmp_music_record_t* dst, const pmp_music_record_t* src);

PMPAPI void pmplib_records_finish(pmp_music_record_t* records, int num_records);

PMPAPI result_t pmplib_records_clone(pmp_music_record_t* dst, const pmp_music_record_t* src, int num_records);

PMPAPI void pmplib_playlist_init(pmp_playlist_t* playlist);

PMPAPI void pmplib_playlist_finish(pmp_playlist_t* playlist);

PMPAPI void pmplib_playlist_clone(pmp_playlist_t* dst, const pmp_playlist_t* src);

PMPAPI void pmplib_playlists_finish(pmp_playlist_t* playlists, int num_playlists);

PMPAPI void pmplib_playlists_clone(pmp_playlist_t* dst, const pmp_playlist_t* src, int num_playlists);

typedef void (*pmplib_enumerate_devid_callback_t)(void *instance, const char *devid);

typedef result_t (*pmplib_create_t)(pmp_t** ptr_pmp, const ucs2char_t* path_to_device, const char *id);

typedef result_t (*pmplib_enumerate_devid_t)(pmplib_enumerate_devid_callback_t callback, void *instance);

PMPAPI uint32_t pmplib_interlocked_increment(uint32_t* count);

PMPAPI uint32_t pmplib_interlocked_decrement(uint32_t* count);

struct tag_pmplib_t;

typedef struct tag_pmplib_t pmplib_t;

PMPAPI result_t pmplib_init(pmplib_t** ptr_pmplib);

PMPAPI result_t pmplib_finish(pmplib_t* pmplib);

PMPAPI result_t pmplib_create(pmplib_t* pmplib, pmp_t** ptr_pmp, const ucs2char_t* path_to_device, const char *id);

PMPAPI result_t pmplib_enumerate_devid(pmplib_t* pmplib, pmplib_enumerate_devid_callback_t callback, void *instance);

#ifdef  __cplusplus
}
#endif/*__cplusplus*/

#endif/*__PMP_H__*/

Generated by Doxygen 1.5.1 on Sat Feb 24 16:48:47 2007.

Copyright 2005-2006 PMPlib Project