1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/*
* Copyright (C) 2003-2009 The Music Player Daemon Project
* http://www.musicpd.org
*
* 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 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.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPD_ENCODER_PLUGIN_H
#define MPD_ENCODER_PLUGIN_H
#include <glib.h>
#include <stdbool.h>
#include <stddef.h>
struct encoder_plugin;
struct audio_format;
struct config_param;
struct tag;
struct encoder {
const struct encoder_plugin *plugin;
};
struct encoder_plugin {
const char *name;
struct encoder *(*init)(const struct config_param *param,
GError **error);
void (*finish)(struct encoder *encoder);
bool (*open)(struct encoder *encoder,
struct audio_format *audio_format,
GError **error);
void (*close)(struct encoder *encoder);
bool (*flush)(struct encoder *encoder, GError **error);
bool (*tag)(struct encoder *encoder, const struct tag *tag,
GError **error);
bool (*write)(struct encoder *encoder,
const void *data, size_t length,
GError **error);
size_t (*read)(struct encoder *encoder, void *dest, size_t length);
};
/**
* Initializes an encoder object. This should be used by encoder
* plugins to initialize their base class.
*/
static inline void
encoder_struct_init(struct encoder *encoder,
const struct encoder_plugin *plugin)
{
encoder->plugin = plugin;
}
/**
* Creates a new encoder object.
*
* @param plugin the encoder plugin
* @param param optional configuration
* @param error location to store the error occuring, or NULL to ignore errors.
* @return an encoder object on success, NULL on failure
*/
static inline struct encoder *
encoder_init(const struct encoder_plugin *plugin,
const struct config_param *param, GError **error)
{
return plugin->init(param, error);
}
/**
* Frees an encoder object.
*
* @param encoder the encoder
*/
static inline void
encoder_finish(struct encoder *encoder)
{
encoder->plugin->finish(encoder);
}
/**
* Opens an encoder object. You must call this prior to using it.
* Before you free it, you must call encoder_close(). You may open
* and close (reuse) one encoder any number of times.
*
* @param encoder the encoder
* @param audio_format the encoder's input audio format; the plugin
* may modify the struct to adapt it to its abilities
* @param error location to store the error occuring, or NULL to ignore errors.
* @return true on success
*/
static inline bool
encoder_open(struct encoder *encoder, struct audio_format *audio_format,
GError **error)
{
return encoder->plugin->open(encoder, audio_format, error);
}
/**
* Closes an encoder object. This disables the encoder, and readies
* it for reusal by calling encoder_open() again.
*
* @param encoder the encoder
*/
static inline void
encoder_close(struct encoder *encoder)
{
if (encoder->plugin->close != NULL)
encoder->plugin->close(encoder);
}
/**
* Flushes an encoder object, make everything which might currently be
* buffered available by encoder_read().
*
* @param encoder the encoder
* @param error location to store the error occuring, or NULL to ignore errors.
* @return true on success
*/
static inline bool
encoder_flush(struct encoder *encoder, GError **error)
{
/* this method is optional */
return encoder->plugin->flush != NULL
? encoder->plugin->flush(encoder, error)
: true;
}
/**
* Sends a tag to the encoder.
*
* @param encoder the encoder
* @param tag the tag object
* @param error location to store the error occuring, or NULL to ignore errors.
* @return true on success
*/
static inline bool
encoder_tag(struct encoder *encoder, const struct tag *tag, GError **error)
{
/* this method is optional */
return encoder->plugin->tag != NULL
? encoder->plugin->tag(encoder, tag, error)
: true;
}
/**
* Writes raw PCM data to the encoder.
*
* @param encoder the encoder
* @param data the buffer containing PCM samples
* @param length the length of the buffer in bytes
* @param error location to store the error occuring, or NULL to ignore errors.
* @return true on success
*/
static inline bool
encoder_write(struct encoder *encoder, const void *data, size_t length,
GError **error)
{
return encoder->plugin->write(encoder, data, length, error);
}
/**
* Reads encoded data from the encoder.
*
* @param encoder the encoder
* @param dest the destination buffer to copy to
* @param length the maximum length of the destination buffer
* @return the number of bytes written to #dest
*/
static inline size_t
encoder_read(struct encoder *encoder, void *dest, size_t length)
{
return encoder->plugin->read(encoder, dest, length);
}
#endif
|
