~sgomin/ddbmedialib/deadbeef_headers : revision 1

1

/*

2

deadbeef.h -- plugin API of the DeaDBeeF audio player

3

http://deadbeef.sourceforge.net

4

5

6

7

This software is provided 'as-is', without any express or implied

8

warranty. In no event will the authors be held liable for any damages

9

arising from the use of this software.

10

11

Permission is granted to anyone to use this software for any purpose,

12

including commercial applications, and to alter it and redistribute it

13

freely, subject to the following restrictions:

14

15

1. The origin of this software must not be misrepresented; you must not

16

claim that you wrote the original software. If you use this software

17

in a product, an acknowledgment in the product documentation would be

18

appreciated but is not required.

19

2. Altered source versions must be plainly marked as such, and must not be

20

misrepresented as being the original software.

21

3. This notice may not be removed or altered from any source distribution.

22

*/

23

24

25

#ifndef __DEADBEEF_H

26

#define __DEADBEEF_H

27

28

#include <stdint.h>

29

#include <time.h>

30

#include <stdio.h>

31

#include <dirent.h>

32

33

#ifdef __cplusplus

34

extern "C" {

35

#endif

36

37

// every plugin must define the following entry-point:

38

// extern "C" DB_plugin_t* $MODULENAME_load (DB_functions_t *api);

39

// where $MODULENAME is a name of module

40

// e.g. if your plugin is called "myplugin.so", $MODULENAME is "myplugin"

41

// this function should return pointer to DB_plugin_t structure

42

// that is enough for both static and dynamic modules

43

44

// backwards compatibility is supported since API version 1.0

45

// that means that the plugins which use the API 1.0 will work without recompiling until API 2.0.

46

//

47

// increments in the major version number mean that there are API breaks, and

48

// plugins must be recompiled to be compatible.

49

//

50

// add DDB_REQUIRE_API_VERSION(x,y) macro when you define the plugin structure

51

// like this:

52

// static DB_decoder_t plugin = {

53

// DDB_REQUIRE_API_VERSION(1,0)

54

// ............

55

// }

56

// this is required for versioning

57

// if you don't do it -- no version checking will be done (useful for debugging/development)

58

//

59

// please DON'T release plugins without version requirement

60

//

61

// to ensure compatibility, use the following before including deadbeef.h:

62

// #define DDB_API_LEVEL x

63

// where x is the minor API version number.

64

// that way, you'll get errors or warnings when using incompatible stuff.

65

//

66

// if you also want to get the deprecation warnings, use the following:

67

// #define DDB_WARN_DEPRECATED 1

68

//

69

// NOTE: deprecation doesn't mean the API is going to be removed, it just means

70

// that there's a better replacement in the newer deadbeef versions.

71

72

// api version history:

73

// 1.9 -- deadbeef-0.7.2

74

// 1.8 -- deadbeef-0.7.0

75

// 1.7 -- deadbeef-0.6.2

76

// 1.6 -- deadbeef-0.6.1

77

// 1.5 -- deadbeef-0.6

78

// 1.4 -- deadbeef-0.5.5

79

// 1.3 -- deadbeef-0.5.3

80

// 1.2 -- deadbeef-0.5.2

81

// 1.1 -- deadbeef-0.5.1

82

// adds pass_through method to dsp plugins for optimization purposes

83

// 1.0 -- deadbeef-0.5.0

84

// 0.10 -- deadbeef-0.4.4-portable-r1 (note: 0.4.4 uses api v0.9)

85

// 0.9 -- deadbeef-0.4.3-portable-build3

86

// 0.8 -- deadbeef-0.4.2

87

// 0.7 -- deabdeef-0.4.0

88

// 0.6 -- deadbeef-0.3.3

89

// 0.5 -- deadbeef-0.3.2

90

// 0.4 -- deadbeef-0.3.0

91

// 0.3 -- deadbeef-0.2.3.2

92

// 0.2 -- deadbeef-0.2.3

93

// 0.1 -- deadbeef-0.2.0

94

95

#define DB_API_VERSION_MAJOR 1

96

#define DB_API_VERSION_MINOR 9

97

98

#define DDB_DEPRECATED(x)

99

100

#ifdef __GNUC__

101

// avoid including glibc headers, this is not very portable

102

#if defined __GNUC__ && defined __GNUC_MINOR__

103

# define __GNUC_PREREQ(maj, min) \

104

((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))

105

#else

106

# define __GNUC_PREREQ(maj, min) 0

107

#endif

108

#undef DDB_DEPRECATED

109

#if __GNUC_PREREQ(4,5)

110

#define DDB_DEPRECATED(x) __attribute__ ((deprecated(x)))

111

#else

112

#define DDB_DEPRECATED(x) __attribute__ ((deprecated))

113

#endif

114

#endif

115

116

#ifndef DDB_API_LEVEL

117

#define DDB_API_LEVEL DB_API_VERSION_MINOR

118

#endif

119

120

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 9)

121

#define DEPRECATED_19 DDB_DEPRECATED("since deadbeef API 1.9")

122

#else

123

#define DEPRECATED_19

124

#endif

125

126

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 8)

127

#define DEPRECATED_18 DDB_DEPRECATED("since deadbeef API 1.8")

128

#else

129

#define DEPRECATED_18

130

#endif

131

132

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 7)

133

#define DEPRECATED_17 DDB_DEPRECATED("since deadbeef API 1.7")

134

#else

135

#define DEPRECATED_17

136

#endif

137

138

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 6)

139

#define DEPRECATED_16 DDB_DEPRECATED("since deadbeef API 1.6")

140

#else

141

#define DEPRECATED_16

142

#endif

143

144

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 5)

145

#define DEPRECATED_15 DDB_DEPRECATED("since deadbeef API 1.5")

146

#else

147

#define DEPRECATED_15

148

#endif

149

150

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 4)

151

#define DEPRECATED_14 DDB_DEPRECATED("since deadbeef API 1.4")

152

#else

153

#define DEPRECATED_14

154

#endif

155

156

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 3)

157

#define DEPRECATED_13 DDB_DEPRECATED("since deadbeef API 1.3")

158

#else

159

#define DEPRECATED_13

160

#endif

161

162

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 2)

163

#define DEPRECATED_12 DDB_DEPRECATED("since deadbeef API 1.2")

164

#else

165

#define DEPRECATED_12

166

#endif

167

168

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 1)

169

#define DEPRECATED_11 DDB_DEPRECATED("since deadbeef API 1.1")

170

#else

171

#define DEPRECATED_11

172

#endif

173

174

#if (DDB_WARN_DEPRECATED && DDB_API_LEVEL >= 0)

175

#define DEPRECATED DDB_DEPRECATED

176

#else

177

#define DEPRECATED

178

#endif

179

180

#define DDB_PLUGIN_SET_API_VERSION\

181

.plugin.api_vmajor = DB_API_VERSION_MAJOR,\

182

.plugin.api_vminor = DB_API_VERSION_MINOR,

183

184

// backwards compat macro

185

#define DB_PLUGIN_SET_API_VERSION DDB_PLUGIN_SET_API_VERSION

186

187

#define PLUG_TEST_COMPAT(plug,x,y) ((plug)->version_major == (x) && (plug)->version_minor >= (y))

188

189

#define DDB_REQUIRE_API_VERSION(x,y)\

190

.plugin.api_vmajor = x,\

191

.plugin.api_vminor = y,

192

193

////////////////////////////

194

// default values for some common config variables should go here

195

196

// network.ctmapping : content-type to plugin mapping

197

#define DDB_DEFAULT_CTMAPPING "audio/mpeg {stdmpg ffmpeg} audio/x-mpeg {stdmpg ffmpeg} application/ogg {stdogg ffmpeg} audio/ogg {stdogg ffmpeg} audio/aac {aac ffmpeg} audio/aacp {aac ffmpeg} audio/x-m4a {aac ffmpeg} audio/wma {wma ffmpeg}"

198

199

////////////////////////////

200

// playlist structures

201

202

// that's a good candidate for redesign

203

// short explanation: PL_MAIN and PL_SEARCH are used as "iter" argument in

204

// playlist functions, to reference main or search playlist, respectively

205

#define PL_MAIN 0

206

#define PL_SEARCH 1

207

208

enum {

209

DDB_IS_SUBTRACK = (1<<0), // file is not single-track, might have metainfo in external file

210

DDB_IS_READONLY = (1<<1), // check this flag to block tag writing (e.g. in iso.wv)

211

DDB_HAS_EMBEDDED_CUESHEET = (1<<2),

212

213

DDB_TAG_ID3V1 = (1<<8),

214

DDB_TAG_ID3V22 = (1<<9),

215

DDB_TAG_ID3V23 = (1<<10),

216

DDB_TAG_ID3V24 = (1<<11),

217

DDB_TAG_APEV2 = (1<<12),

218

DDB_TAG_VORBISCOMMENTS = (1<<13),

219

DDB_TAG_CUESHEET = (1<<14),

220

DDB_TAG_ICY = (1<<15),

221

DDB_TAG_ITUNES = (1<<16),

222

223

DDB_TAG_MASK = 0x000fff00

224

};

225

226

// playlist item

227

// these are "public" fields, available to plugins

228

typedef struct DB_playItem_s {

229

int startsample; // start sample of track, or -1 for auto

230

int endsample; // end sample of track, or -1 for auto

231

int shufflerating; // sort order for shuffle mode

232

} ddb_playItem_t;

233

234

typedef ddb_playItem_t DB_playItem_t;

235

236

typedef struct {

237

} ddb_playlist_t;

238

239

typedef struct DB_metaInfo_s {

240

struct DB_metaInfo_s *next;

241

const char *key;

242

const char *value;

243

} DB_metaInfo_t;

244

245

// FIXME: that needs to be in separate plugin

246

247

#define JUNK_STRIP_ID3V2 1

248

#define JUNK_STRIP_APEV2 2

249

#define JUNK_STRIP_ID3V1 4

250

#define JUNK_WRITE_ID3V2 8

251

#define JUNK_WRITE_APEV2 16

252

#define JUNK_WRITE_ID3V1 32

253

254

typedef struct DB_id3v2_frame_s {

255

struct DB_id3v2_frame_s *next;

256

char id[5];

257

uint32_t size;

258

uint8_t flags[2];

259

uint8_t data[0];

260

} DB_id3v2_frame_t;

261

262

typedef struct DB_id3v2_tag_s {

263

uint8_t version[2];

264

uint8_t flags;

265

DB_id3v2_frame_t *frames;

266

} DB_id3v2_tag_t;

267

268

typedef struct DB_apev2_frame_s {

269

struct DB_apev2_frame_s *next;

270

uint32_t flags;

271

char key[256];

272

uint32_t size; // size of data

273

uint8_t data[0];

274

} DB_apev2_frame_t;

275

276

typedef struct DB_apev2_tag_s {

277

uint32_t version;

278

uint32_t flags;

279

DB_apev2_frame_t *frames;

280

} DB_apev2_tag_t;

281

282

// plugin types

283

enum {

284

DB_PLUGIN_DECODER = 1,

285

DB_PLUGIN_OUTPUT = 2,

286

DB_PLUGIN_DSP = 3,

287

DB_PLUGIN_MISC = 4,

288

DB_PLUGIN_VFS = 5,

289

DB_PLUGIN_PLAYLIST = 6,

290

DB_PLUGIN_GUI = 7,

291

};

292

293

// output plugin states

294

enum output_state_t {

295

OUTPUT_STATE_STOPPED = 0,

296

OUTPUT_STATE_PLAYING = 1,

297

OUTPUT_STATE_PAUSED = 2,

298

};

299

300

// playback order

301

enum playback_order_t {

302

PLAYBACK_ORDER_LINEAR = 0,

303

PLAYBACK_ORDER_SHUFFLE_TRACKS = 1,

304

PLAYBACK_ORDER_RANDOM = 2,

305

PLAYBACK_ORDER_SHUFFLE_ALBUMS = 3,

306

};

307

308

// playback modes

309

enum playback_mode_t {

310

PLAYBACK_MODE_LOOP_ALL = 0, // loop playlist

311

PLAYBACK_MODE_NOLOOP = 1, // don't loop

312

PLAYBACK_MODE_LOOP_SINGLE = 2, // loop single track

313

};

314

315

#if (DDB_API_LEVEL >= 8)

316

// playlist change info, used in the DB_EV_PLAYLISTCHANGED p1 argument

317

enum ddb_playlist_change_t {

318

DDB_PLAYLIST_CHANGE_CONTENT, // this is the most generic one, will work for the cases when p1 was omitted (0)

319

DDB_PLAYLIST_CHANGE_CREATED,

320

DDB_PLAYLIST_CHANGE_DELETED,

321

DDB_PLAYLIST_CHANGE_POSITION,

322

DDB_PLAYLIST_CHANGE_TITLE,

323

DDB_PLAYLIST_CHANGE_SELECTION,

324

DDB_PLAYLIST_CHANGE_SEARCHRESULT,

325

DDB_PLAYLIST_CHANGE_PLAYQUEUE,

326

};

327

#endif

328

329

typedef struct {

330

int event;

331

int size;

332

} ddb_event_t;

333

334

typedef struct {

335

ddb_event_t ev;

336

DB_playItem_t *track;

337

float playtime; // for SONGFINISHED event -- for how many seconds track was playing

338

time_t started_timestamp; // time when "track" started playing

339

} ddb_event_track_t;

340

341

typedef struct {

342

ddb_event_t ev;

343

DB_playItem_t *from;

344

DB_playItem_t *to;

345

float playtime; // for SONGCHANGED event -- for how many seconds prev track was playing

346

time_t started_timestamp; // time when "from" started playing

347

} ddb_event_trackchange_t;

348

349

typedef struct {

350

ddb_event_t ev;

351

int state;

352

} ddb_event_state_t;

353

354

typedef struct {

355

ddb_event_t ev;

356

DB_playItem_t *track;

357

float playpos;

358

} ddb_event_playpos_t;

359

360

typedef struct DB_conf_item_s {

361

char *key;

362

char *value;

363

struct DB_conf_item_s *next;

364

} DB_conf_item_t;

365

366

// event callback type

367

typedef int (*DB_callback_t)(ddb_event_t *, uintptr_t data);

368

369

// events

370

enum {

371

DB_EV_NEXT = 1, // switch to next track

372

DB_EV_PREV = 2, // switch to prev track

373

DB_EV_PLAY_CURRENT = 3, // play current track (will start/unpause if stopped or paused)

374

DB_EV_PLAY_NUM = 4, // play track nr. p1

375

DB_EV_STOP = 5, // stop current track

376

DB_EV_PAUSE = 6, // pause playback

377

DB_EV_PLAY_RANDOM = 7, // play random track

378

DB_EV_TERMINATE = 8, // must be sent to player thread to terminate

379

DB_EV_PLAYLIST_REFRESH = 9, // [DEPRECATED IN API LEVEL 8, use DB_EV_PLAYLISTCHANGED instead] save and redraw current playlist

380

DB_EV_REINIT_SOUND = 10, // reinitialize sound output with current output_plugin config value

381

DB_EV_CONFIGCHANGED = 11, // one or more config options were changed

382

DB_EV_TOGGLE_PAUSE = 12,

383

DB_EV_ACTIVATED = 13, // will be fired every time player is activated

384

DB_EV_PAUSED = 14, // player was paused or unpaused

385

386

DB_EV_PLAYLISTCHANGED = 15, // playlist contents were changed (e.g. metadata in any track)

387

// DB_EV_PLAYLISTCHANGED NOTE: it's usually sent on LARGE changes,

388

// when multiple tracks are affected, while for single tracks

389

// the DB_EV_TRACKINFOCHANGED is preferred

390

// added in API level 8:

391

// p1 is one of ddb_playlist_change_t enum values, detailing what exactly has been changed.

392

393

DB_EV_VOLUMECHANGED = 16, // volume was changed

394

DB_EV_OUTPUTCHANGED = 17, // sound output plugin changed

395

DB_EV_PLAYLISTSWITCHED = 18, // playlist switch occured

396

DB_EV_SEEK = 19, // seek current track to position p1 (ms)

397

DB_EV_ACTIONSCHANGED = 20, // plugin actions were changed, e.g. for reinitializing gui

398

DB_EV_DSPCHAINCHANGED = 21, // emitted when any parameter of the main dsp chain has been changed

399

400

// since 1.5

401

#if (DDB_API_LEVEL >= 5)

402

DB_EV_SELCHANGED = 22, // selection changed in playlist p1 iter p2, ctx should be a pointer to playlist viewer instance, which caused the change, or NULL

403

DB_EV_PLUGINSLOADED = 23, // after all plugins have been loaded and connected

404

#endif

405

406

#if (DDB_API_LEVEL >= 8)

407

DB_EV_FOCUS_SELECTION = 24, // tell playlist viewer to focus on selection

408

#endif

409

410

// -----------------

411

// structured events

412

413

DB_EV_FIRST = 1000,

414

DB_EV_SONGCHANGED = 1000, // current song changed from one to another, ctx=ddb_event_trackchange_t

415

DB_EV_SONGSTARTED = 1001, // song started playing, ctx=ddb_event_track_t

416

DB_EV_SONGFINISHED = 1002, // song finished playing, ctx=ddb_event_track_t

417

418

DB_EV_TRACKINFOCHANGED = 1004, // trackinfo was changed (included medatata, playback status, playqueue state, etc), ctx=ddb_event_track_t

419

// DB_EV_TRACKINFOCHANGED NOTE: when multiple tracks change, DB_EV_PLAYLISTCHANGED may be sent instead,

420

// for speed reasons, so always handle both events.

421

422

DB_EV_SEEKED = 1005, // seek happened, ctx=ddb_event_playpos_t

423

424

// since 1.5

425

#if (DDB_API_LEVEL >= 5)

426

// NOTE: this is not a structured event, but too late to fix, needs to stay here for backwards compat

427

DB_EV_TRACKFOCUSCURRENT = 1006, // user wants to highlight/find the current playing track

428

#endif

429

430

DB_EV_MAX

431

};

432

433

// preset columns, working using IDs

434

// DON'T add new ids in range 2-7, they are reserved for backwards compatibility

435

enum pl_column_t {

436

DB_COLUMN_FILENUMBER = 0,

437

DB_COLUMN_PLAYING = 1,

438

DB_COLUMN_ALBUM_ART = 8,

439

};

440

441

// replaygain constants

442

enum {

443

DDB_REPLAYGAIN_ALBUMGAIN,

444

DDB_REPLAYGAIN_ALBUMPEAK,

445

DDB_REPLAYGAIN_TRACKGAIN,

446

DDB_REPLAYGAIN_TRACKPEAK,

447

};

448

449

// sort order constants

450

enum ddb_sort_order_t {

451

DDB_SORT_DESCENDING,

452

DDB_SORT_ASCENDING,

453

// since 1.3

454

#if (DDB_API_LEVEL >= 3)

455

DDB_SORT_RANDOM,

456

#endif

457

};

458

459

enum ddb_sys_directory_t {

460

DDB_SYS_DIR_CONFIG = 1,

461

DDB_SYS_DIR_PREFIX = 2,

462

DDB_SYS_DIR_DOC = 3,

463

DDB_SYS_DIR_PLUGIN = 4,

464

DDB_SYS_DIR_PIXMAP = 5,

465

DDB_SYS_DIR_CACHE = 6,

466

};

467

468

// typecasting macros

469

#define DB_PLUGIN(x) ((DB_plugin_t *)(x))

470

#define DB_CALLBACK(x) ((DB_callback_t)(x))

471

#define DB_EVENT(x) ((ddb_event_t *)(x))

472

#define DB_PLAYITEM(x) ((DB_playItem_t *)(x))

473

474

// FILE object wrapper for vfs access

475

typedef struct {

476

struct DB_vfs_s *vfs;

477

} DB_FILE;

478

479

// md5 calc control structure (see md5/md5.h)

480

typedef struct DB_md5_s {

481

char data[88];

482

} DB_md5_t;

483

484

typedef struct {

485

int bps;

486

int channels;

487

int samplerate;

488

uint32_t channelmask;

489

int is_float; // bps must be 32 if this is true

490

int is_bigendian;

491

} ddb_waveformat_t;

492

493

// since 1.5

494

#if (DDB_API_LEVEL >= 5)

495

#define DDB_FREQ_BANDS 256

496

#define DDB_FREQ_MAX_CHANNELS 9

497

typedef struct ddb_audio_data_s {

498

const ddb_waveformat_t *fmt;

499

const float *data;

500

int nframes;

501

} ddb_audio_data_t;

502

503

typedef struct ddb_fileadd_data_s {

504

int visibility;

505

ddb_playlist_t *plt;

506

ddb_playItem_t *track;

507

} ddb_fileadd_data_t;

508

#endif

509

510

// since 1.8

511

#if (DDB_API_LEVEL >= 8)

512

enum {

513

DDB_TF_CONTEXT_HAS_INDEX = 1,

514

DDB_TF_CONTEXT_HAS_ID = 2,

515

DDB_TF_CONTEXT_NO_DYNAMIC = 4, // skip dynamic fields (%playback_time%)

516

#if (DDB_API_LEVEL >= 9)

517

// Don't convert linebreaks to semicolons

518

DDB_TF_CONTEXT_MULTILINE = 8,

519

#endif

520

};

521

522

// context for title formatting interpreter

523

typedef struct {

524

int _size; // must be set to sizeof(tf_context_t)

525

uint32_t flags; // DDB_TF_CONTEXT_ flags

526

ddb_playItem_t *it; // track to get information from, or NULL

527

ddb_playlist_t *plt; // playlist in which the track resides, or NULL

528

529

// NOTE: when plt is NULL, it means that the track is not in any playlist,

530

// that is -- playlist will never be automatically guessed, for performance

531

// reasons.

532

533

// index of the track in playlist the track belongs to

534

// if present, DDB_TF_CONTEXT_HAS_INDEX flag must be set

535

int idx;

536

537

// predefined column id, one of the DB_COLUMN_

538

// if present, DDB_TF_CONTEXT_HAS_ID flag must be set

539

int id;

540

541

int iter; // playlist iteration (PL_MAIN, PL_SEARCH)

542

543

// update is a returned value

544

// meaning:

545

// 0: no automatic updates

546

// <0: updates on every call

547

// >0: number of milliseconds between updates / until next update

548

int update;

549

} ddb_tf_context_t;

550

#endif

551

552

// forward decl for plugin struct

553

struct DB_plugin_s;

554

555

// player api definition

556

typedef struct {

557

// versioning

558

int vmajor;

559

int vminor;

560

561

// md5sum calc

562

void (*md5) (uint8_t sig[16], const char *in, int len);

563

void (*md5_to_str) (char *str, const uint8_t sig[16]);

564

void (*md5_init)(DB_md5_t *s);

565

void (*md5_append)(DB_md5_t *s, const uint8_t *data, int nbytes);

566

void (*md5_finish)(DB_md5_t *s, uint8_t digest[16]);

567

568

// playback control

569

struct DB_output_s* (*get_output) (void);

570

float (*playback_get_pos) (void); // [0..100]

571

void (*playback_set_pos) (float pos); // [0..100]

572

573

// streamer access

574

DB_playItem_t *(*streamer_get_playing_track) (void);

575

DB_playItem_t *(*streamer_get_streaming_track) (void);

576

float (*streamer_get_playpos) (void);

577

int (*streamer_ok_to_read) (int len);

578

void (*streamer_reset) (int full);

579

int (*streamer_read) (char *bytes, int size);

580

void (*streamer_set_bitrate) (int bitrate);

581

int (*streamer_get_apx_bitrate) (void);

582

struct DB_fileinfo_s *(*streamer_get_current_fileinfo) (void);

583

int (*streamer_get_current_playlist) (void);

584

struct ddb_dsp_context_s * (*streamer_get_dsp_chain) (void);

585

void (*streamer_set_dsp_chain) (struct ddb_dsp_context_s *chain);

586

void (*streamer_dsp_refresh) (void); // call after changing parameters

587

588

// system folders

589

// normally functions will return standard folders derived from --prefix

590

// portable version will return pathes specified in comments below

591

const char *(*get_config_dir) (void) DEPRECATED_18; // installdir/config | $XDG_CONFIG_HOME/.config/deadbeef

592

const char *(*get_prefix) (void) DEPRECATED_18; // installdir | PREFIX

593

const char *(*get_doc_dir) (void) DEPRECATED_18; // installdir/doc | DOCDIR

594

const char *(*get_plugin_dir) (void) DEPRECATED_18; // installdir/plugins | LIBDIR/deadbeef

595

const char *(*get_pixmap_dir) (void) DEPRECATED_18; // installdir/pixmaps | PREFIX "/share/deadbeef/pixmaps"

596

597

// process control

598

void (*quit) (void);

599

600

// threading

601

intptr_t (*thread_start) (void (*fn)(void *ctx), void *ctx);

602

intptr_t (*thread_start_low_priority) (void (*fn)(void *ctx), void *ctx);

603

int (*thread_join) (intptr_t tid);

604

int (*thread_detach) (intptr_t tid);

605

void (*thread_exit) (void *retval);

606

uintptr_t (*mutex_create) (void);

607

uintptr_t (*mutex_create_nonrecursive) (void);

608

void (*mutex_free) (uintptr_t mtx);

609

int (*mutex_lock) (uintptr_t mtx);

610

int (*mutex_unlock) (uintptr_t mtx);

611

uintptr_t (*cond_create) (void);

612

void (*cond_free) (uintptr_t cond);

613

int (*cond_wait) (uintptr_t cond, uintptr_t mutex);

614

int (*cond_signal) (uintptr_t cond);

615

int (*cond_broadcast) (uintptr_t cond);

616

617

/////// playlist management //////

618

void (*plt_ref) (ddb_playlist_t *plt);

619

void (*plt_unref) (ddb_playlist_t *plt);

620

621

// total number of playlists

622

int (*plt_get_count) (void);

623

624

// 1st item in playlist nr. 'plt'

625

DB_playItem_t * (*plt_get_head) (int plt);

626

627

// nr. of selected items in playlist nr. 'plt'

628

int (*plt_get_sel_count) (int plt);

629

630

// add new playlist into position before nr. 'before', with title='title'

631

// returns index of new playlist

632

int (*plt_add) (int before, const char *title);

633

634

// remove playlist nr. plt

635

void (*plt_remove) (int plt);

636

637

// clear playlist

638

void (*plt_clear) (ddb_playlist_t *plt);

639

void (*pl_clear) (void);

640

641

// set current playlist

642

void (*plt_set_curr) (ddb_playlist_t *plt);

643

void (*plt_set_curr_idx) (int plt);

644

645

// get current playlist

646

// note: caller is responsible to call plt_unref after using pointer

647

// returned by plt_get_curr

648

ddb_playlist_t *(*plt_get_curr) (void);

649

int (*plt_get_curr_idx) (void);

650

651

// move playlist nr. 'from' into position before nr. 'before', where

652

// before=-1 means last position

653

void (*plt_move) (int from, int before);

654

655

// playlist saving and loading

656

DB_playItem_t * (*plt_load) (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data) DEPRECATED_15;

657

int (*plt_save) (ddb_playlist_t *plt, DB_playItem_t *first, DB_playItem_t *last, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);

658

659

ddb_playlist_t *(*plt_get_for_idx) (int idx);

660

int (*plt_get_title) (ddb_playlist_t *plt, char *buffer, int bufsize);

661

int (*plt_set_title) (ddb_playlist_t *plt, const char *title);

662

663

// increments modification index

664

void (*plt_modified) (ddb_playlist_t *handle);

665

666

// returns modication index

667

// the index is incremented by 1 every time playlist changes

668

int (*plt_get_modification_idx) (ddb_playlist_t *handle);

669

670

// return index of an item in specified playlist, or -1 if not found

671

int (*plt_get_item_idx) (ddb_playlist_t *plt, DB_playItem_t *it, int iter);

672

673

// playlist metadata

674

// this kind of metadata is stored in playlist (dbpl) files

675

// that is, this is the properties of playlist itself,

676

// not of the tracks in the playlist.

677

// for example, playlist tab color can be stored there, etc

678

679

// add meta if it doesn't exist yet

680

void (*plt_add_meta) (ddb_playlist_t *handle, const char *key, const char *value);

681

682

// replace (or add) existing meta

683

void (*plt_replace_meta) (ddb_playlist_t *handle, const char *key, const char *value);

684

685

// append meta to existing one, or add if doesn't exist

686

void (*plt_append_meta) (ddb_playlist_t *handle, const char *key, const char *value);

687

688

// set integer meta (works same as replace)

689

void (*plt_set_meta_int) (ddb_playlist_t *handle, const char *key, int value);

690

691

// set float meta (works same as replace)

692

void (*plt_set_meta_float) (ddb_playlist_t *handle, const char *key, float value);

693

694

// plt_find_meta must always be used in the pl_lock/unlock block

695

const char *(*plt_find_meta) (ddb_playlist_t *handle, const char *key);

696

697

// returns head of metadata linked list, for direct access

698

// remember pl_lock/unlock

699

DB_metaInfo_t * (*plt_get_metadata_head) (ddb_playlist_t *handle);

700

701

// delete meta item from list

702

void (*plt_delete_metadata) (ddb_playlist_t *handle, DB_metaInfo_t *meta);

703

704

// returns integer value of requested meta, def is the default value if not found

705

int (*plt_find_meta_int) (ddb_playlist_t *handle, const char *key, int def);

706

707

// returns float value of requested meta, def is the default value if not found

708

float (*plt_find_meta_float) (ddb_playlist_t *handle, const char *key, float def);

709

710

// delete all metadata

711

void (*plt_delete_all_meta) (ddb_playlist_t *handle);

712

713

// operating on playlist items

714

DB_playItem_t * (*plt_insert_item) (ddb_playlist_t *playlist, DB_playItem_t *after, DB_playItem_t *it);

715

DB_playItem_t * (*plt_insert_file) (ddb_playlist_t *playlist, DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data) DEPRECATED_15;

716

DB_playItem_t *(*plt_insert_dir) (ddb_playlist_t *plt, DB_playItem_t *after, const char *dirname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data) DEPRECATED_15;

717

void (*plt_set_item_duration) (ddb_playlist_t *plt, DB_playItem_t *it, float duration);

718

int (*plt_remove_item) (ddb_playlist_t *playlist, DB_playItem_t *it);

719

int (*plt_getselcount) (ddb_playlist_t *playlist);

720

float (*plt_get_totaltime) (ddb_playlist_t *plt);

721

int (*plt_get_item_count) (ddb_playlist_t *plt, int iter);

722

int (*plt_delete_selected) (ddb_playlist_t *plt);

723

void (*plt_set_cursor) (ddb_playlist_t *plt, int iter, int cursor);

724

int (*plt_get_cursor) (ddb_playlist_t *plt, int iter);

725

void (*plt_select_all) (ddb_playlist_t *plt);

726

void (*plt_crop_selected) (ddb_playlist_t *plt);

727

DB_playItem_t *(*plt_get_first) (ddb_playlist_t *plt, int iter);

728

DB_playItem_t *(*plt_get_last) (ddb_playlist_t *plt, int iter);

729

DB_playItem_t * (*plt_get_item_for_idx) (ddb_playlist_t *playlist, int idx, int iter);

730

void (*plt_move_items) (ddb_playlist_t *to, int iter, ddb_playlist_t *from, DB_playItem_t *drop_before, uint32_t *indexes, int count);

731

void (*plt_copy_items) (ddb_playlist_t *to, int iter, ddb_playlist_t * from, DB_playItem_t *before, uint32_t *indices, int cnt);

732

void (*plt_search_reset) (ddb_playlist_t *plt);

733

void (*plt_search_process) (ddb_playlist_t *plt, const char *text);

734

735

// sort using the title formatting v1 (deprecated)

736

void (*plt_sort) (ddb_playlist_t *plt, int iter, int id, const char *format, int order) DEPRECATED_18;

737

738

// add files and folders to current playlist

739

int (*plt_add_file) (ddb_playlist_t *plt, const char *fname, int (*cb)(DB_playItem_t *it, void *data), void *user_data) DEPRECATED_15;

740

int (*plt_add_dir) (ddb_playlist_t *plt, const char *dirname, int (*cb)(DB_playItem_t *it, void *data), void *user_data) DEPRECATED_15;

741

742

// cuesheet support

743

DB_playItem_t *(*plt_insert_cue_from_buffer) (ddb_playlist_t *plt, DB_playItem_t *after, DB_playItem_t *origin, const uint8_t *buffer, int buffersize, int numsamples, int samplerate);

744

DB_playItem_t * (*plt_insert_cue) (ddb_playlist_t *plt, DB_playItem_t *after, DB_playItem_t *origin, int numsamples, int samplerate);

745

746

// playlist locking

747

void (*pl_lock) (void);

748

void (*pl_unlock) (void);

749

750

// playlist tracks access

751

DB_playItem_t * (*pl_item_alloc) (void);

752

DB_playItem_t * (*pl_item_alloc_init) (const char *fname, const char *decoder_id);

753

void (*pl_item_ref) (DB_playItem_t *it);

754

void (*pl_item_unref) (DB_playItem_t *it);

755

void (*pl_item_copy) (DB_playItem_t *out, DB_playItem_t *in);

756

757

// request lock for adding files to playlist

758

// this function may return -1 if it is not possible to add files right now.

759

// caller must cancel operation in this case,

760

// or wait until previous operation finishes

761

int (*pl_add_files_begin) (ddb_playlist_t *plt) DEPRECATED_15;

762

763

// release the lock for adding files to playlist

764

// end must be called when add files operation is finished

765

void (*pl_add_files_end) (void) DEPRECATED_15;

766

767

// most of this functions are self explanatory

768

// if you don't get what they do -- look in the code

769

770

// --- the following functions work with current playlist ---

771

772

// get index of the track in MAIN

773

int (*pl_get_idx_of) (DB_playItem_t *it);

774

775

// get index of the track in MAIN or SEARCH

776

int (*pl_get_idx_of_iter) (DB_playItem_t *it, int iter);

777

778

// get track for index in MAIN

779

DB_playItem_t * (*pl_get_for_idx) (int idx);

780

781

// get track for index in MAIN or SEARCH

782

DB_playItem_t * (*pl_get_for_idx_and_iter) (int idx, int iter);

783

784

// get total play time of all tracks in MAIN

785

float (*pl_get_totaltime) (void);

786

787

// get number of tracks in MAIN or SEARCH

788

int (*pl_getcount) (int iter);

789

790

// delete selected tracks

791

int (*pl_delete_selected) (void);

792

793

// set cursor position in MAIN or SEARCH

794

void (*pl_set_cursor) (int iter, int cursor);

795

796

// get cursor position in MAIN

797

int (*pl_get_cursor) (int iter);

798

799

// remove all except selected tracks

800

void (*pl_crop_selected) (void);

801

802

// get number of selected tracks

803

int (*pl_getselcount) (void);

804

805

// get first track in MAIN or SEARCH

806

DB_playItem_t *(*pl_get_first) (int iter);

807

808

// get last track in MAIN or SEARCH

809

DB_playItem_t *(*pl_get_last) (int iter);

810

811

// --- misc functions ---

812

813

// mark the track as selected or unselected (1 or 0 respectively)

814

void (*pl_set_selected) (DB_playItem_t *it, int sel);

815

816

// test whether the track is selected

817

int (*pl_is_selected) (DB_playItem_t *it);

818

819

// save current playlist

820

int (*pl_save_current) (void);

821

822

// save all playlists

823

int (*pl_save_all) (void);

824

825

// select all tracks in current playlist

826

void (*pl_select_all) (void);

827

828

// get next track

829

DB_playItem_t *(*pl_get_next) (DB_playItem_t *it, int iter);

830

831

// get previous track

832

DB_playItem_t *(*pl_get_prev) (DB_playItem_t *it, int iter);

833

834

/*

835

pl_format_title formats the line for display in playlist

836

@it pointer to playlist item

837

@idx number of that item in playlist (or -1)

838

@s output buffer

839

@size size of output buffer

840

@id one of IDs defined in pl_column_id_t enum, can be -1

841

@fmt format string, used if id is -1

842

format is printf-alike. specification:

843

%a artist

844

%t title

845

%b album

846

%B band / album artist

847

%n track

848

%l length (duration)

849

%y year

850

%g genre

851

%c comment

852

%r copyright

853

%T tags

854

%f filename without path

855

%F full pathname/uri

856

%d directory without path (e.g. /home/user/file.mp3 -> user)

857

%D directory name with full path (e.g. /home/user/file.mp3 -> /home/user)

858

more to come

859

*/

860

int (*pl_format_title) (DB_playItem_t *it, int idx, char *s, int size, int id, const char *fmt) DEPRECATED_18;

861

862

// _escaped version wraps all conversions with '' and replaces every ' in conversions with \'

863

int (*pl_format_title_escaped) (DB_playItem_t *it, int idx, char *s, int size, int id, const char *fmt) DEPRECATED_18;

864

865

// format duration 't' (fractional seconds) into string, for display in playlist

866

void (*pl_format_time) (float t, char *dur, int size);

867

868

// find which playlist the specified item belongs to, returns NULL if none

869

ddb_playlist_t * (*pl_get_playlist) (DB_playItem_t *it);

870

871

// direct access to metadata structures

872

// not thread-safe, make sure to wrap with pl_lock/pl_unlock

873

DB_metaInfo_t * (*pl_get_metadata_head) (DB_playItem_t *it); // returns head of metadata linked list

874

void (*pl_delete_metadata) (DB_playItem_t *it, DB_metaInfo_t *meta);

875

876

// high-level access to metadata

877

void (*pl_add_meta) (DB_playItem_t *it, const char *key, const char *value);

878

void (*pl_append_meta) (DB_playItem_t *it, const char *key, const char *value);

879

void (*pl_set_meta_int) (DB_playItem_t *it, const char *key, int value);

880

void (*pl_set_meta_float) (DB_playItem_t *it, const char *key, float value);

881

void (*pl_delete_meta) (DB_playItem_t *it, const char *key);

882

883

// this function is not thread-safe

884

// make sure to wrap it with pl_lock/pl_unlock block

885

const char *(*pl_find_meta) (DB_playItem_t *it, const char *key);

886

887

// following functions are thread-safe

888

int (*pl_find_meta_int) (DB_playItem_t *it, const char *key, int def);

889

float (*pl_find_meta_float) (DB_playItem_t *it, const char *key, float def);

890

void (*pl_replace_meta) (DB_playItem_t *it, const char *key, const char *value);

891

void (*pl_delete_all_meta) (DB_playItem_t *it);

892

float (*pl_get_item_duration) (DB_playItem_t *it);

893

uint32_t (*pl_get_item_flags) (DB_playItem_t *it);

894

void (*pl_set_item_flags) (DB_playItem_t *it, uint32_t flags);

895

void (*pl_items_copy_junk)(DB_playItem_t *from, DB_playItem_t *first, DB_playItem_t *last);

896

// idx is one of DDB_REPLAYGAIN_* constants

897

void (*pl_set_item_replaygain) (DB_playItem_t *it, int idx, float value);

898

float (*pl_get_item_replaygain) (DB_playItem_t *it, int idx);

899

900

// playqueue support (obsolete since API 1.8)

901

int (*pl_playqueue_push) (DB_playItem_t *it) DEPRECATED_18;

902

void (*pl_playqueue_clear) (void) DEPRECATED_18;

903

void (*pl_playqueue_pop) (void) DEPRECATED_18;

904

void (*pl_playqueue_remove) (DB_playItem_t *it) DEPRECATED_18;

905

int (*pl_playqueue_test) (DB_playItem_t *it) DEPRECATED_18;

906

907

// volume control

908

void (*volume_set_db) (float dB);

909

float (*volume_get_db) (void);

910

void (*volume_set_amp) (float amp);

911

float (*volume_get_amp) (void);

912

float (*volume_get_min_db) (void);

913

914

// junk reading/writing

915

int (*junk_id3v1_read) (DB_playItem_t *it, DB_FILE *fp);

916

int (*junk_id3v1_find) (DB_FILE *fp);

917

int (*junk_id3v1_write) (FILE *fp, DB_playItem_t *it, const char *enc);

918

int (*junk_id3v2_find) (DB_FILE *fp, int *psize);

919

int (*junk_id3v2_read) (DB_playItem_t *it, DB_FILE *fp);

920

int (*junk_id3v2_read_full) (DB_playItem_t *it, DB_id3v2_tag_t *tag, DB_FILE *fp);

921

int (*junk_id3v2_convert_24_to_23) (DB_id3v2_tag_t *tag24, DB_id3v2_tag_t *tag23);

922

int (*junk_id3v2_convert_23_to_24) (DB_id3v2_tag_t *tag23, DB_id3v2_tag_t *tag24);

923

int (*junk_id3v2_convert_22_to_24) (DB_id3v2_tag_t *tag22, DB_id3v2_tag_t *tag24);

924

void (*junk_id3v2_free) (DB_id3v2_tag_t *tag);

925

int (*junk_id3v2_write) (FILE *file, DB_id3v2_tag_t *tag);

926

DB_id3v2_frame_t *(*junk_id3v2_add_text_frame) (DB_id3v2_tag_t *tag, const char *frame_id, const char *value);

927

int (*junk_id3v2_remove_frames) (DB_id3v2_tag_t *tag, const char *frame_id);

928

int (*junk_apev2_read) (DB_playItem_t *it, DB_FILE *fp);

929

int (*junk_apev2_read_mem) (DB_playItem_t *it, char *mem, int size);

930

int (*junk_apev2_read_full) (DB_playItem_t *it, DB_apev2_tag_t *tag_store, DB_FILE *fp);

931

int (*junk_apev2_read_full_mem) (DB_playItem_t *it, DB_apev2_tag_t *tag_store, char *mem, int memsize);

932

int (*junk_apev2_find) (DB_FILE *fp, int32_t *psize, uint32_t *pflags, uint32_t *pnumitems);

933

int (*junk_apev2_remove_frames) (DB_apev2_tag_t *tag, const char *frame_id);

934

DB_apev2_frame_t * (*junk_apev2_add_text_frame) (DB_apev2_tag_t *tag, const char *frame_id, const char *value);

935

void (*junk_apev2_free) (DB_apev2_tag_t *tag);

936

int (*junk_apev2_write) (FILE *fp, DB_apev2_tag_t *tag, int write_header, int write_footer);

937

int (*junk_get_leading_size) (DB_FILE *fp);

938

int (*junk_get_leading_size_stdio) (FILE *fp);

939

void (*junk_copy) (DB_playItem_t *from, DB_playItem_t *first, DB_playItem_t *last);

940

const char * (*junk_detect_charset) (const char *s);

941

int (*junk_recode) (const char *in, int inlen, char *out, int outlen, const char *cs);

942

int (*junk_iconv) (const char *in, int inlen, char *out, int outlen, const char *cs_in, const char *cs_out);

943

int (*junk_rewrite_tags) (DB_playItem_t *it, uint32_t flags, int id3v2_version, const char *id3v1_encoding);

944

945

// vfs

946

DB_FILE* (*fopen) (const char *fname);

947

void (*fclose) (DB_FILE *f);

948

size_t (*fread) (void *ptr, size_t size, size_t nmemb, DB_FILE *stream);

949

int (*fseek) (DB_FILE *stream, int64_t offset, int whence);

950

int64_t (*ftell) (DB_FILE *stream);

951

void (*rewind) (DB_FILE *stream);

952

int64_t (*fgetlength) (DB_FILE *stream);

953

const char *(*fget_content_type) (DB_FILE *stream);

954

void (*fset_track) (DB_FILE *stream, DB_playItem_t *it);

955

void (*fabort) (DB_FILE *stream);

956

957

// message passing

958

int (*sendmessage) (uint32_t id, uintptr_t ctx, uint32_t p1, uint32_t p2);

959

960

// convenience functions to send events, uses sendmessage internally

961

ddb_event_t *(*event_alloc) (uint32_t id);

962

void (*event_free) (ddb_event_t *ev);

963

int (*event_send) (ddb_event_t *ev, uint32_t p1, uint32_t p2);

964

965

// configuration access

966

//

967

// conf_get_str_fast is not thread-safe, and

968

// must only be used from within conf_lock/conf_unlock block

969

// it should be preferred for fast non-blocking lookups

970

//

971

// all the other config access functions are thread safe

972

void (*conf_lock) (void);

973

void (*conf_unlock) (void);

974

const char * (*conf_get_str_fast) (const char *key, const char *def);

975

void (*conf_get_str) (const char *key, const char *def, char *buffer, int buffer_size);

976

float (*conf_get_float) (const char *key, float def);

977

int (*conf_get_int) (const char *key, int def);

978

int64_t (*conf_get_int64) (const char *key, int64_t def);

979

void (*conf_set_str) (const char *key, const char *val);

980

void (*conf_set_int) (const char *key, int val);

981

void (*conf_set_int64) (const char *key, int64_t val);

982

void (*conf_set_float) (const char *key, float val);

983

DB_conf_item_t * (*conf_find) (const char *group, DB_conf_item_t *prev);

984

void (*conf_remove_items) (const char *key);

985

int (*conf_save) (void);

986

987

// plugin communication

988

struct DB_decoder_s **(*plug_get_decoder_list) (void);

989

struct DB_vfs_s **(*plug_get_vfs_list) (void);

990

struct DB_output_s **(*plug_get_output_list) (void);

991

struct DB_dsp_s **(*plug_get_dsp_list) (void);

992

struct DB_playlist_s **(*plug_get_playlist_list) (void);

993

struct DB_plugin_s **(*plug_get_list) (void);

994

const char **(*plug_get_gui_names) (void);

995

const char * (*plug_get_decoder_id) (const char *id);

996

void (*plug_remove_decoder_id) (const char *id);

997

struct DB_plugin_s *(*plug_get_for_id) (const char *id);

998

999

// misc utilities

1000

// returns 1 if the track is represented as a local file

1001

// returns 0 if it's a remote file, e.g. a network stream

1002

// since API 1.5 it also returns 1 for vfs tracks, e.g. from ZIP files

1003

int (*is_local_file) (const char *fname);

1004

1005

// pcm utilities

1006

int (*pcm_convert) (const ddb_waveformat_t * inputfmt, const char *input, const ddb_waveformat_t *outputfmt, char *output, int inputsize);

1007

1008

// dsp preset management

1009

int (*dsp_preset_load) (const char *fname, struct ddb_dsp_context_s **head);

1010

int (*dsp_preset_save) (const char *fname, struct ddb_dsp_context_s *head);

1011

void (*dsp_preset_free) (struct ddb_dsp_context_s *head);

1012

1013

// since 1.2

1014

#if (DDB_API_LEVEL >= 2)

1015

ddb_playlist_t *(*plt_alloc) (const char *title);

1016

void (*plt_free) (ddb_playlist_t *plt);

1017

1018

void (*plt_set_fast_mode) (ddb_playlist_t *plt, int fast);

1019

int (*plt_is_fast_mode) (ddb_playlist_t *plt);

1020

1021

const char * (*metacache_add_string) (const char *str);

1022

void (*metacache_remove_string) (const char *str);

1023

void (*metacache_ref) (const char *str);

1024

void (*metacache_unref) (const char *str);

1025

1026

// this function must return original un-overriden value (ignoring the keys prefixed with '!')

1027

// it's not thread-safe, and must be used under the same conditions as the

1028

// pl_find_meta

1029

const char *(*pl_find_meta_raw) (DB_playItem_t *it, const char *key);

1030

#endif

1031

1032

// since 1.3

1033

#if (DDB_API_LEVEL >= 3)

1034

int (*streamer_dsp_chain_save) (void);

1035

#endif

1036

1037

// since 1.4

1038

#if (DDB_API_LEVEL >= 4)

1039

int (*pl_get_meta) (DB_playItem_t *it, const char *key, char *val, int size);

1040

int (*pl_get_meta_raw) (DB_playItem_t *it, const char *key, char *val, int size);

1041

int (*plt_get_meta) (ddb_playlist_t *handle, const char *key, char *val, int size);

1042

1043

// fast way to test if a field exists in playitem

1044

int (*pl_meta_exists) (DB_playItem_t *it, const char *key);

1045

#endif

1046

1047

// since 1.5

1048

#if (DDB_API_LEVEL >= 5)

1049

// register/unregister for getting continuous wave data

1050

// mainly for visualization

1051

// ctx must be unique

1052

// the waveform data can be arbitrary size

1053

// the samples are interleaved

1054

void (*vis_waveform_listen) (void *ctx, void (*callback)(void *ctx, ddb_audio_data_t *data));

1055

void (*vis_waveform_unlisten) (void *ctx);

1056

1057

// register/unregister for getting continuous spectrum (frequency domain) data

1058

// mainly for visualization

1059

// ctx must be unique

1060

// the data always contains DDB_FREQ_BANDS frames

1061

// max number of channels is DDB_FREQ_MAX_CHANNELS

1062

// the samples are non-interleaved

1063

void (*vis_spectrum_listen) (void *ctx, void (*callback)(void *ctx, ddb_audio_data_t *data));

1064

void (*vis_spectrum_unlisten) (void *ctx);

1065

1066

// this is useful to mute/unmute audio, and query the muted status, from

1067

// plugins, without touching the volume control

1068

void (*audio_set_mute) (int mute);

1069

int (*audio_is_mute) (void);

1070

1071

// this is useful for prompting a user when he attempts to quit the player

1072

// while something is working in background, e.g. the Converter,

1073

// and let him finish or cancel the background jobs.

1074

void (*background_job_increment) (void);

1075

void (*background_job_decrement) (void);

1076

int (*have_background_jobs) (void);

1077

1078

// utility function to get plt idx from handle

1079

int (*plt_get_idx) (ddb_playlist_t *plt);

1080

1081

// save referenced playlist in config

1082

// same as pl_save_current, but for index

1083

int (*plt_save_n) (int n);

1084

1085

// same as pl_save_current, but for playlist pointer

1086

int (*plt_save_config) (ddb_playlist_t *plt);

1087

1088

// register file added callback

1089

// the callback will be called for each file

1090

// the visibility is taken from plt_add_* arguments

1091

// the callback must return 0 to continue, or -1 to abort the operation.

1092

// returns ID

1093

int (*listen_file_added) (int (*callback)(ddb_fileadd_data_t *data, void *user_data), void *user_data);

1094

void (*unlisten_file_added) (int id);

1095

1096

int (*listen_file_add_beginend) (void (*callback_begin) (ddb_fileadd_data_t *data, void *user_data), void (*callback_end)(ddb_fileadd_data_t *data, void *user_data), void *user_data);

1097

void (*unlisten_file_add_beginend) (int id);

1098

1099

// visibility is a number, which tells listeners about the caller.

1100

// the value DDB_FILEADD_VISIBILITY_GUI (or 0) is reserved for callers which

1101

// want the GUI to intercept the calls and show visual updates.

1102

//

1103

// this is the default value passed from plt_load, plt_add_dir, plt_add_file.

1104

//

1105

// the values up to 10 are registered for deadbeef itself, so please avoid

1106

// using them in your plugins, unless you really know what you're doing.

1107

// any values above 10 are free for any use.

1108

//

1109

// the "callback", if not NULL, will be called with the passed "user_data",

1110

// for each track.

1111

//

1112

// the registered listeners will be called too, the ddb_fileadd_data_t

1113

// has the visibility

1114

DB_playItem_t * (*plt_load2) (int visibility, ddb_playlist_t *plt, ddb_playItem_t *after, const char *fname, int *pabort, int (*callback)(DB_playItem_t *it, void *user_data), void *user_data);

1115

int (*plt_add_file2) (int visibility, ddb_playlist_t *plt, const char *fname, int (*callback)(DB_playItem_t *it, void *user_data), void *user_data);

1116

int (*plt_add_dir2) (int visibility, ddb_playlist_t *plt, const char *dirname, int (*callback)(DB_playItem_t *it, void *user_data), void *user_data);

1117

ddb_playItem_t * (*plt_insert_file2) (int visibility, ddb_playlist_t *playlist, ddb_playItem_t *after, const char *fname, int *pabort, int (*callback)(DB_playItem_t *it, void *user_data), void *user_data);

1118

ddb_playItem_t *(*plt_insert_dir2) (int visibility, ddb_playlist_t *plt, ddb_playItem_t *after, const char *dirname, int *pabort, int (*callback)(DB_playItem_t *it, void *user_data), void *user_data);

1119

1120

// request lock for adding files to playlist

1121

// returns 0 on success

1122

// this function may return -1 if it is not possible to add files right now.

1123

// caller must cancel operation in this case,

1124

// or wait until previous operation finishes

1125

// NOTE: it's not guaranteed that all deadbeef versions support

1126

// adding the files to different playlists in parallel.

1127

int (*plt_add_files_begin) (ddb_playlist_t *plt, int visibility);

1128

1129

// release the lock for adding files to playlist

1130

// end must be called when add files operation is finished

1131

void (*plt_add_files_end) (ddb_playlist_t *plt, int visibility);

1132

1133

// deselect all tracks in playlist

1134

void (*plt_deselect_all) (ddb_playlist_t *plt);

1135

#endif

1136

// since 1.6

1137

#if (DDB_API_LEVEL >= 6)

1138

void (*plt_set_scroll) (ddb_playlist_t *plt, int scroll);

1139

int (*plt_get_scroll) (ddb_playlist_t *plt);

1140

#endif

1141

// since 1.8

1142

#if (DDB_API_LEVEL >= 8)

1143

// **** title formatting v2 ****

1144

1145

// compile the input title formatting string into bytecode

1146

// script: freeform string with title formatting special characters in it

1147

// returns the pointer to compiled bytecode, which must be tf_free'd by the caller.

1148

char *(*tf_compile) (const char *script);

1149

1150

// free the code returned by tf_compile

1151

void (*tf_free) (char *code);

1152

1153

// evaluate the titleformatting script in a given context

1154

// ctx: a pointer to ddb_tf_context_t structure initialized by the caller

1155

// code: the bytecode data created by tf_compile

1156

// out: buffer allocated by the caller, must be big enough to fit the output string

1157

// outlen: the size of out buffer

1158

// returns -1 on fail, output size on success

1159

int (*tf_eval) (ddb_tf_context_t *ctx, const char *code, char *out, int outlen);

1160

1161

// sort using title formatting v2

1162

void (*plt_sort_v2) (ddb_playlist_t *plt, int iter, int id, const char *format, int order);

1163

1164

// playqueue APIs

1165

int (*playqueue_push) (DB_playItem_t *it);

1166

void (*playqueue_pop) (void);

1167

void (*playqueue_remove) (DB_playItem_t *it);

1168

void (*playqueue_clear) (void);

1169

int (*playqueue_test) (DB_playItem_t *it);

1170

int (*playqueue_get_count) (void);

1171

DB_playItem_t *(*playqueue_get_item) (int n);

1172

int (*playqueue_remove_nth) (int n);

1173

void (*playqueue_insert_at) (int n, DB_playItem_t *it);

1174

1175

// system directory API, returns path by id from ddb_sys_directory_t enum

1176

const char *(*get_system_dir) (int dir_id);

1177

1178

// set the selected playlist for the ongoing plugin action.

1179

// the "set" function is expected to be called by the UI plugin,

1180

// while the "get" is expected to be called by the action code.

1181

void (*action_set_playlist) (ddb_playlist_t *plt);

1182

1183

// returns one of:

1184

// selected playlist for context menu for the DDB_ACTION_CTX_PLAYLIST,

1185

// or the current active playlist for any other context.

1186

// returned value cannot be NULL

1187

// returned value is refcounted, so remember to call plt_unref.

1188

ddb_playlist_t *(*action_get_playlist) (void);

1189

1190

// convert legacy title formatting to the new format, usable with tf_compile

1191

void (*tf_import_legacy) (const char *fmt, char *out, int outsize);

1192

#endif

1193

} DB_functions_t;

1194

1195

// NOTE: an item placement must be selected like this

1196

// if (flags & DB_ACTION_COMMON) -> main menu, or nowhere, or where GUI plugin wants

1197

// basically, to put it into main menu, prefix the item title with the menu name

1198

// e.g. title = "File/MyItem" --> this will add the item under File menu

1199

//

1200

// if (flags & PLAYLIST) -> playlist (tab) context menu

1201

//

1202

// if (none of the above) -> track context menu

1203

1204

enum {

1205

/* Action in main menu (or whereever ui prefers) */

1206

DB_ACTION_COMMON = 1 << 0,

1207

1208

/* Can handle single track */

1209

DB_ACTION_SINGLE_TRACK = 1 << 1,

1210

1211

/* Can handle multiple tracks */

1212

DB_ACTION_MULTIPLE_TRACKS = 1 << 2,

1213

1214

/* DEPRECATED in API 1.5 */

1215

DB_ACTION_ALLOW_MULTIPLE_TRACKS = 1 << 2,

1216

1217

/* DEPRECATED in API 1.5, ignored in callback2 */

1218

/* Action can (and prefer) traverse multiple tracks by itself */

1219

DB_ACTION_CAN_MULTIPLE_TRACKS = 1 << 3,

1220

1221

/* Action is inactive */

1222

DB_ACTION_DISABLED = 1 << 4,

1223

1224

/* DEPRECATED in API 1.5, ignored in callback2 */

1225

/* since 1.2 */

1226

/* Action for the playlist (tab) */

1227

DB_ACTION_PLAYLIST = 1 << 5,

1228

1229

/* add item to menu(s), if contains slash symbol(s) */

1230

DB_ACTION_ADD_MENU = 1 << 6

1231

};

1232

1233

// action contexts

1234

// since 1.5

1235

#if (DDB_API_LEVEL >= 5)

1236

enum {

1237

DDB_ACTION_CTX_MAIN,

1238

DDB_ACTION_CTX_SELECTION,

1239

// NOTE: starting with API 1.8, plugins should be using the

1240

// action_get_playlist function for getting the playlist pointer.

1241

DDB_ACTION_CTX_PLAYLIST,

1242

DDB_ACTION_CTX_NOWPLAYING,

1243

DDB_ACTION_CTX_COUNT

1244

};

1245

#endif

1246

1247

struct DB_plugin_action_s;

1248

1249

typedef int (*DB_plugin_action_callback_t) (struct DB_plugin_action_s *action, void *userdata);

1250

#if (DDB_API_LEVEL >= 5)

1251

typedef int (*DB_plugin_action_callback2_t) (struct DB_plugin_action_s *action, int ctx);

1252

#endif

1253

1254

typedef struct DB_plugin_action_s {

1255

const char *title;

1256

const char *name;

1257

uint32_t flags;

1258

// the use of "callback" is deprecated,

1259

// only use it if the code must be compatible with API 1.4

1260

// otherwise switch to callback2

1261

DB_plugin_action_callback_t callback;

1262

struct DB_plugin_action_s *next;

1263

#if (DDB_API_LEVEL >= 5)

1264

DB_plugin_action_callback2_t callback2;

1265

#endif

1266

} DB_plugin_action_t;

1267

1268

// base plugin interface

1269

typedef struct DB_plugin_s {

1270

// type must be one of DB_PLUGIN_ types

1271

int32_t type;

1272

// api version

1273

int16_t api_vmajor;

1274

int16_t api_vminor;

1275

// plugin version

1276

int16_t version_major;

1277

int16_t version_minor;

1278

1279

uint32_t flags; // currently unused

1280

uint32_t reserved1;

1281

uint32_t reserved2;

1282

uint32_t reserved3;

1283

1284

// any of those can be left NULL

1285

// though it's much better to fill them with something useful

1286

const char *id; // id used for serialization and runtime binding

1287

const char *name; // short name

1288

const char *descr; // short description (what the plugin is doing)

1289

const char *copyright; // copyright notice(s), list of developers, links to original works, etc

1290

const char *website; // plugin website

1291

1292

// plugin-specific command interface; can be NULL

1293

int (*command) (int cmd, ...);

1294

1295

// start is called to start plugin; can be NULL

1296

int (*start) (void);

1297

1298

// stop is called to deinit plugin; can be NULL

1299

int (*stop) (void);

1300

1301

// connect is called to setup connections between different plugins

1302

// it is called after all plugin's start method was executed

1303

// can be NULL

1304

// NOTE for GUI plugin developers: don't initialize your widgets/windows in

1305

// the connect method. look for up-to-date information on wiki:

1306

// http://github.com/Alexey-Yakovenko/deadbeef/wiki/Porting-GUI-plugins-to-deadbeef-from-0.5.x-to-0.6.0

1307

int (*connect) (void);

1308

1309

// opposite of connect, will be called before stop, while all plugins are still

1310

// in "started" state

1311

int (*disconnect) (void);

1312

1313

// exec_cmdline may be called at any moment when user sends commandline to player

1314

// can be NULL if plugin doesn't support commandline processing

1315

// cmdline is 0-separated list of strings, guaranteed to have 0 at the end

1316

// cmdline_size is number of bytes pointed by cmdline

1317

int (*exec_cmdline) (const char *cmdline, int cmdline_size);

1318

1319

// @returns linked list of actions for the specified track

1320

// when it is NULL -- the plugin must return list of all actions

1321

DB_plugin_action_t* (*get_actions) (DB_playItem_t *it);

1322

1323

// mainloop will call this function for every plugin

1324

// so that plugins may handle all events;

1325

// can be NULL

1326

int (*message) (uint32_t id, uintptr_t ctx, uint32_t p1, uint32_t p2);

1327

1328

// plugin configuration dialog is constructed from this data

1329

// can be NULL

1330

const char *configdialog;

1331

} DB_plugin_t;

1332

1333

// file format stuff

1334

1335

// channel mask - combine following flags to tell streamer which channels are

1336

// present in input/output streams

1337

enum {

1338

DDB_SPEAKER_FRONT_LEFT = 0x1,

1339

DDB_SPEAKER_FRONT_RIGHT = 0x2,

1340

DDB_SPEAKER_FRONT_CENTER = 0x4,

1341

DDB_SPEAKER_LOW_FREQUENCY = 0x8,

1342

DDB_SPEAKER_BACK_LEFT = 0x10,

1343

DDB_SPEAKER_BACK_RIGHT = 0x20,

1344

DDB_SPEAKER_FRONT_LEFT_OF_CENTER = 0x40,

1345

DDB_SPEAKER_FRONT_RIGHT_OF_CENTER = 0x80,

1346

DDB_SPEAKER_BACK_CENTER = 0x100,

1347

DDB_SPEAKER_SIDE_LEFT = 0x200,

1348

DDB_SPEAKER_SIDE_RIGHT = 0x400,

1349

DDB_SPEAKER_TOP_CENTER = 0x800,

1350

DDB_SPEAKER_TOP_FRONT_LEFT = 0x1000,

1351

DDB_SPEAKER_TOP_FRONT_CENTER = 0x2000,

1352

DDB_SPEAKER_TOP_FRONT_RIGHT = 0x4000,

1353

DDB_SPEAKER_TOP_BACK_LEFT = 0x8000,

1354

DDB_SPEAKER_TOP_BACK_CENTER = 0x10000,

1355

DDB_SPEAKER_TOP_BACK_RIGHT = 0x20000

1356

};

1357

1358

typedef struct DB_fileinfo_s {

1359

struct DB_decoder_s *plugin;

1360

1361

// these parameters should be set in decoder->open

1362

ddb_waveformat_t fmt;

1363

1364

// readpos should be updated to current decoder time (in seconds)

1365

float readpos;

1366

1367

// this is the (optional) file handle, that can be used by streamer to

1368

// request interruption of current read operation

1369

DB_FILE *file;

1370

} DB_fileinfo_t;

1371

1372

enum {

1373

// Decoders should try to output 16 bit stream when this flag is set, for

1374

// performance reasons.

1375

DDB_DECODER_HINT_16BIT = 0x1,

1376

#if (DDB_API_LEVEL >= 8)

1377

// Decoders should only call the streamer_set_bitrate from plugin.read function,

1378

// and only when this flag is set.

1379

DDB_DECODER_HINT_NEED_BITRATE = 0x2,

1380

// Decoders can do their own infinite looping when this flag is set, in the

1381

// "Loop Single" looping mode.

1382

DDB_DECODER_HINT_CAN_LOOP = 0x4,

1383

#endif

1384

};

1385

1386

// decoder plugin

1387

typedef struct DB_decoder_s {

1388

DB_plugin_t plugin;

1389

1390

DB_fileinfo_t *(*open) (uint32_t hints);

1391

1392

// init is called to prepare song to be started

1393

int (*init) (DB_fileinfo_t *info, DB_playItem_t *it);

1394

1395

// free is called after decoding is finished

1396

void (*free) (DB_fileinfo_t *info);

1397

1398

// read is called by streamer to decode specified number of bytes

1399

// must return number of bytes that were successfully decoded (sample aligned)

1400

int (*read) (DB_fileinfo_t *info, char *buffer, int nbytes);

1401

1402

int (*seek) (DB_fileinfo_t *info, float seconds);

1403

1404

// perform seeking in samples (if possible)

1405

// return -1 if failed, or 0 on success

1406

// if -1 is returned, that will mean that streamer must skip that song

1407

int (*seek_sample) (DB_fileinfo_t *info, int sample);

1408

1409

// 'insert' is called to insert new item to playlist

1410

// decoder is responsible to calculate duration, split it into subsongs, load cuesheet, etc

1411

// after==NULL means "prepend before 1st item in playlist"

1412

DB_playItem_t * (*insert) (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname);

1413

1414

int (*numvoices) (DB_fileinfo_t *info);

1415

void (*mutevoice) (DB_fileinfo_t *info, int voice, int mute);

1416

1417

int (*read_metadata) (DB_playItem_t *it);

1418

int (*write_metadata) (DB_playItem_t *it);

1419

1420

// NULL terminated array of all supported extensions

1421

// examples:

1422

// { "aac", "wma", "tak", NULL } -- supports 3 file extensions

1423

// since API 1.9: { "*", NULL } -- supports any file extensions

1424

const char **exts;

1425

1426

// NULL terminated array of all supported prefixes (UADE support needs that)

1427

// e.g. "mod.song_title"

1428

const char **prefixes;

1429

1430

#if (DDB_API_LEVEL >= 7)

1431

// This function's purpose is to open the file, so that the file handle is

1432

// immediately accessible via DB_fileinfo_t, and can be used with fabort.

1433

// If a plugin is using open2, it should not reopen the file from init.

1434

// Plugins _must_ implement open even if open2 is present,

1435

// because existing code may rely on it.

1436

DB_fileinfo_t *(*open2) (uint32_t hints, DB_playItem_t *it);

1437

#endif

1438

} DB_decoder_t;

1439

1440

// output plugin

1441

typedef struct DB_output_s {

1442

DB_plugin_t plugin;

1443

// init is called once at plugin activation

1444

int (*init) (void);

1445

// free is called if output plugin was changed to another, or unload is about to happen

1446

int (*free) (void);

1447

// reconfigure output to another format

1448

int (*setformat) (ddb_waveformat_t *fmt);

1449

// play, stop, pause, unpause are called by deadbeef in response to user

1450

// events, or as part of streaming process

1451

int (*play) (void);

1452

int (*stop) (void);

1453

int (*pause) (void);

1454

int (*unpause) (void);

1455

// one of output_state_t enum values

1456

int (*state) (void);

1457

// soundcard enumeration (can be NULL)

1458

void (*enum_soundcards) (void (*callback)(const char *name, const char *desc, void*), void *userdata);

1459

1460

// parameters of current output

1461

ddb_waveformat_t fmt;

1462

1463

// set to 1 if volume control is done internally by plugin

1464

int has_volume;

1465

} DB_output_t;

1466

1467

// dsp plugin

1468

// see also: examples/dsp_template.c in git

1469

#define DDB_INIT_DSP_CONTEXT(var,type,plug) {\

1470

memset(var,0,sizeof(type));\

1471

var->ctx.plugin=plug;\

1472

var->ctx.enabled=1;\

1473

}

1474

1475

typedef struct ddb_dsp_context_s {

1476

// pointer to DSP plugin which created this context

1477

struct DB_dsp_s *plugin;

1478

1479

// pointer to the next DSP plugin context in the chain

1480

struct ddb_dsp_context_s *next;

1481

1482

// read only flag; set by DB_dsp_t::enable

1483

unsigned enabled : 1;

1484

} ddb_dsp_context_t;

1485

1486

typedef struct DB_dsp_s {

1487

DB_plugin_t plugin;

1488

1489

ddb_dsp_context_t* (*open) (void);

1490

1491

void (*close) (ddb_dsp_context_t *ctx);

1492

1493

// samples are always interleaved floating point

1494

// returned value is number of output frames (multichannel samples)

1495

// plugins are allowed to modify channels, samplerate, channelmask in the fmt structure

1496

// buffer size can fit up to maxframes frames

1497

// by default ratio=1, and plugins don't need to touch it unless they have to

1498

int (*process) (ddb_dsp_context_t *ctx, float *samples, int frames, int maxframes, ddb_waveformat_t *fmt, float *ratio);

1499

1500

void (*reset) (ddb_dsp_context_t *ctx);

1501

1502

// num_params can be NULL, to indicate that plugin doesn't expose any params

1503

//

1504

// if num_params is non-NULL -- get_param_name, set_param and get_param must

1505

// all be implemented

1506

//

1507

// param names are for display-only, and are allowed to contain spaces

1508

int (*num_params) (void);

1509

const char *(*get_param_name) (int p);

1510

void (*set_param) (ddb_dsp_context_t *ctx, int p, const char *val);

1511

void (*get_param) (ddb_dsp_context_t *ctx, int p, char *str, int len);

1512

1513

// config dialog implementation uses set/get param, so they must be

1514

// implemented if this is nonzero

1515

const char *configdialog;

1516

1517

// since 1.1

1518

#if (DDB_API_LEVEL >= 1)

1519

// can be NULL

1520

// should return 1 if the DSP plugin will not touch data with the current parameters;

1521

// 0 otherwise

1522

int (*can_bypass) (ddb_dsp_context_t *ctx, ddb_waveformat_t *fmt);

1523

#endif

1524

} DB_dsp_t;

1525

1526

// misc plugin

1527

// purpose is to provide extra services

1528

// e.g. scrobbling, converting, tagging, custom gui, etc.

1529

// misc plugins should be mostly event driven, so no special entry points in them

1530

typedef struct {

1531

DB_plugin_t plugin;

1532

} DB_misc_t;

1533

1534

// vfs plugin

1535

// provides means for reading, seeking, etc

1536

// api is based on stdio

1537

typedef struct DB_vfs_s {

1538

DB_plugin_t plugin;

1539

1540

// capabilities

1541

const char **(*get_schemes) (void); // NULL-terminated list of supported schemes, e.g. {"http://", "ftp://", NULL}; can be NULL

1542

1543

int (*is_streaming) (void); // return 1 if the plugin streaming data over slow connection, e.g. http; plugins will avoid scanning entire files if this is the case

1544

1545

int (*is_container) (const char *fname); // should return 1 if this plugin can parse specified file

1546

1547

// this allows interruption of hanging network streams

1548

void (*abort) (DB_FILE *stream);

1549

1550

// file access, follows stdio API with few extension

1551

DB_FILE* (*open) (const char *fname);

1552

void (*close) (DB_FILE *f);

1553

size_t (*read) (void *ptr, size_t size, size_t nmemb, DB_FILE *stream);

1554

int (*seek) (DB_FILE *stream, int64_t offset, int whence);

1555

int64_t (*tell) (DB_FILE *stream);

1556

void (*rewind) (DB_FILE *stream);

1557

int64_t (*getlength) (DB_FILE *stream);

1558

1559

// should return mime-type of a stream, if known; can be NULL

1560

const char * (*get_content_type) (DB_FILE *stream);

1561

1562

// associates stream with a track, to allow dynamic metadata updating, like

1563

// in icy protocol

1564

void (*set_track) (DB_FILE *f, DB_playItem_t *it);

1565

1566

// folder access, follows dirent API, and uses dirent data structures

1567

int (*scandir) (const char *dir, struct dirent ***namelist, int (*selector) (const struct dirent *), int (*cmp) (const struct dirent **, const struct dirent **));

1568

1569

#if (DDB_API_LEVEL >= 6)

1570

// returns URI scheme for a given file name, e.g. "zip://"

1571

// can be NULL

1572

// can return NULL

1573

const char *(*get_scheme_for_name) (const char *fname);

1574

#endif

1575

} DB_vfs_t;

1576

1577

// gui plugin

1578

// only one gui plugin can be running at the same time

1579

// should provide GUI services to other plugins

1580

1581

// this structure represents a gui dialog with callbacks to set/get params

1582

// documentation should be available here:

1583

// http://github.com/Alexey-Yakovenko/deadbeef/wiki/GUI-Script-Syntax

1584

typedef struct {

1585

const char *title;

1586

const char *layout;

1587

void (*set_param) (const char *key, const char *value);

1588

void (*get_param) (const char *key, char *value, int len, const char *def);

1589

1590

#if (DDB_API_LEVEL >= 4)

1591

void *parent;

1592

#endif

1593

} ddb_dialog_t;

1594

1595

enum {

1596

ddb_button_ok,

1597

ddb_button_cancel,

1598

ddb_button_close,

1599

ddb_button_apply,

1600

ddb_button_yes,

1601

ddb_button_no,

1602

ddb_button_max,

1603

};

1604

1605

typedef struct DB_gui_s {

1606

DB_plugin_t plugin;

1607

1608

// returns response code (ddb_button_*)

1609

// buttons is a bitset, e.g. (1<<ddb_button_ok)|(1<<ddb_button_cancel)

1610

int (*run_dialog) (ddb_dialog_t *dlg, uint32_t buttons, int (*callback)(int button, void *ctx), void *ctx);

1611

} DB_gui_t;

1612

1613

// playlist plugin

1614

typedef struct DB_playlist_s {

1615

DB_plugin_t plugin;

1616

1617

DB_playItem_t * (*load) (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname, int *pabort, int (*cb)(DB_playItem_t *it, void *data), void *user_data);

1618

1619

// will save items from first to last (inclusive)

1620

// format is determined by extension

1621

// playlist is protected from changes during the call

1622

int (*save) (ddb_playlist_t *plt, const char *fname, DB_playItem_t *first, DB_playItem_t *last);

1623

1624

const char **extensions; // NULL-terminated list of supported file extensions, e.g. {"m3u", "pls", NULL}

1625

1626

// since 1.5

1627

#if (DDB_API_LEVEL >= 5)

1628

DB_playItem_t * (*load2) (int visibility, ddb_playlist_t *plt, DB_playItem_t *after, const char *fname, int *pabort);

1629

#endif

1630

} DB_playlist_t;

1631

1632

#undef DDB_DEPRECATED

1633

#undef DEPRECATED

1634

1635

#ifdef __cplusplus

1636

}

1637

#endif

1638

1639

#endif // __DEADBEEF_H