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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
|
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Base declarations for working with software encoders
*
* Copyright (C) 2006 Michael Sevakis
*
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef ENC_BASE_H
#define ENC_BASE_H
/** encoder config structures **/
/** aiff_enc.codec **/
struct aiff_enc_config
{
#if 0
unsigned long sample_depth;
#endif
};
/** mp3_enc.codec **/
#define MP3_BITR_CAP_8 (1 << 0)
#define MP3_BITR_CAP_16 (1 << 1)
#define MP3_BITR_CAP_24 (1 << 2)
#define MP3_BITR_CAP_32 (1 << 3)
#define MP3_BITR_CAP_40 (1 << 4)
#define MP3_BITR_CAP_48 (1 << 5)
#define MP3_BITR_CAP_56 (1 << 6)
#define MP3_BITR_CAP_64 (1 << 7)
#define MP3_BITR_CAP_80 (1 << 8)
#define MP3_BITR_CAP_96 (1 << 9)
#define MP3_BITR_CAP_112 (1 << 10)
#define MP3_BITR_CAP_128 (1 << 11)
#define MP3_BITR_CAP_144 (1 << 12)
#define MP3_BITR_CAP_160 (1 << 13)
#define MP3_BITR_CAP_192 (1 << 14)
#define MP3_BITR_CAP_224 (1 << 15)
#define MP3_BITR_CAP_256 (1 << 16)
#define MP3_BITR_CAP_320 (1 << 17)
#define MP3_ENC_NUM_BITR 18
/* MPEG 1 */
#define MPEG1_SAMPR_CAPS (SAMPR_CAP_32 | SAMPR_CAP_48 | SAMPR_CAP_44)
#define MPEG1_BITR_CAPS (MP3_BITR_CAP_32 | MP3_BITR_CAP_40 | MP3_BITR_CAP_48 | \
MP3_BITR_CAP_56 | MP3_BITR_CAP_64 | MP3_BITR_CAP_80 | \
MP3_BITR_CAP_96 | MP3_BITR_CAP_112 | MP3_BITR_CAP_128 | \
MP3_BITR_CAP_160 | MP3_BITR_CAP_192 | MP3_BITR_CAP_224 | \
MP3_BITR_CAP_256 | MP3_BITR_CAP_320)
/* MPEG 2 */
#define MPEG2_SAMPR_CAPS (SAMPR_CAP_22 | SAMPR_CAP_24 | SAMPR_CAP_16)
#define MPEG2_BITR_CAPS (MP3_BITR_CAP_8 | MP3_BITR_CAP_16 | MP3_BITR_CAP_24 | \
MP3_BITR_CAP_32 | MP3_BITR_CAP_40 | MP3_BITR_CAP_48 | \
MP3_BITR_CAP_56 | MP3_BITR_CAP_64 | MP3_BITR_CAP_80 | \
MP3_BITR_CAP_96 | MP3_BITR_CAP_112 | MP3_BITR_CAP_128 | \
MP3_BITR_CAP_144 | MP3_BITR_CAP_160)
#if 0
/* MPEG 2.5 */
#define MPEG2_5_SAMPR_CAPS (SAMPR_CAP_8 | SAMPR_CAP_12 | SAMPR_CAP_11)
#define MPEG2_5_BITR_CAPS MPEG2_BITR_CAPS
#endif
/* HAVE_MPEG* defines mainly apply to the bitrate menu */
#if (REC_SAMPR_CAPS & MPEG1_SAMPR_CAPS) || defined (HAVE_SPDIF_REC)
#define HAVE_MPEG1_SAMPR
#endif
#if (REC_SAMPR_CAPS & MPEG2_SAMPR_CAPS) || defined (HAVE_SPDIF_REC)
#define HAVE_MPEG2_SAMPR
#endif
#if 0
#if (REC_SAMPR_CAPS & MPEG2_5_SAMPR_CAPS) || defined (HAVE_SPDIF_REC)
#define HAVE_MPEG2_5_SAMPR
#endif
#endif /* 0 */
#define MP3_ENC_SAMPR_CAPS (MPEG1_SAMPR_CAPS | MPEG2_SAMPR_CAPS)
/* This number is count of full encoder set */
#define MP3_ENC_NUM_SAMPR 6
#if 0
extern const unsigned long mp3_enc_sampr[MP3_ENC_NUM_SAMPR];
#endif
extern const unsigned long mp3_enc_bitr[MP3_ENC_NUM_BITR];
struct mp3_enc_config
{
unsigned long bitrate;
};
#define MP3_ENC_BITRATE_CFG_DEFAULT 11 /* 128 */
#define MP3_ENC_BITRATE_CFG_VALUE_LIST "8,16,24,32,40,48,56,64,80,96," \
"112,128,144,160,192,224,256,320"
/** wav_enc.codec **/
#define WAV_ENC_SAMPR_CAPS SAMPR_CAP_ALL
struct wav_enc_config
{
#if 0
unsigned long sample_depth;
#endif
};
/** wavpack_enc.codec **/
#define WAVPACK_ENC_SAMPR_CAPS SAMPR_CAP_ALL
struct wavpack_enc_config
{
#if 0
unsigned long sample_depth;
#endif
};
struct encoder_config
{
union
{
/* states which *_enc_config member is valid */
int rec_format; /* REC_FORMAT_* value */
int afmt; /* AFMT_* value */
};
union
{
struct mp3_enc_config mp3_enc;
struct wavpack_enc_config wavpack_enc;
struct wav_enc_config wav_enc;
};
};
/** Encoder chunk macros and definitions **/
#define CHUNKF_START_FILE 0x0001ul /* This chunk starts a new file */
#define CHUNKF_END_FILE 0x0002ul /* This chunk ends the current file */
#define CHUNKF_PRERECORD 0x0010ul /* This chunk is prerecord data,
a new file could start anytime */
#define CHUNKF_ABORT 0x0020ul /* Encoder should not finish this
chunk */
#define CHUNKF_ERROR (~0ul ^ (~0ul >> 1)) /* An error has occured
(passed to/from encoder). Use the
sign bit to check (long)flags < 0. */
#define CHUNKF_ALLFLAGS (0x0033ul | CHUNKF_ERROR)
/* Header at the beginning of every encoder chunk */
#ifdef DEBUG
#define H_TO_BE32 htobe32
#define ENC_CHUNK_MAGIC H_TO_BE32(('P' << 24) | ('T' << 16) | ('Y' << 8) | 'R')
#endif
struct enc_chunk_hdr
{
#ifdef DEBUG
unsigned long id; /* overflow detection - 'PTYR' - acronym for
"PTYR Tells You Right" ;) */
#endif
unsigned long flags; /* in/out: flags used by encoder and file
writing */
size_t enc_size; /* out: amount of encoder data written to
chunk */
unsigned long num_pcm; /* out: number of PCM samples eaten during
processing
(<= size of allocated buffer) */
unsigned char *enc_data; /* out: pointer to enc_size_written bytes
of encoded audio data in chunk */
/* Encoder defined data follows header. Can be audio data + any other
stuff the encoder needs to handle on a per chunk basis */
};
/* Paranoia: be sure header size is 4-byte aligned */
#define ENC_CHUNK_HDR_SIZE \
ALIGN_UP_P2(sizeof (struct enc_chunk_hdr), 2)
/* Skip the chunk header and return data */
#define ENC_CHUNK_SKIP_HDR(t, hdr) \
((typeof (t))((char *)hdr + ENC_CHUNK_HDR_SIZE))
/* Cast p to struct enc_chunk_hdr * */
#define ENC_CHUNK_HDR(p) \
((struct enc_chunk_hdr *)(p))
enum enc_events
{
/* File writing events - data points to enc_file_event_data */
ENC_START_FILE = 0, /* a new file has been opened and no data has yet
been written */
ENC_WRITE_CHUNK, /* write the current chunk to disk */
ENC_END_FILE, /* current file about to be closed and all valid
data has been written */
/* Encoder buffer events - data points to enc_buffer_event_data */
ENC_REC_NEW_STREAM, /* Take steps to finish current stream and start
new */
};
/**
* encoder can write extra data to the file such as headers or more encoded
* samples and must update sizes and samples accordingly.
*/
struct enc_file_event_data
{
struct enc_chunk_hdr *chunk; /* Current chunk */
size_t new_enc_size; /* New size of chunk */
unsigned long new_num_pcm; /* New number of pcm in chunk */
const char *filename; /* filename to open if ENC_START_FILE */
int rec_file; /* Current file or < 0 if none */
unsigned long num_pcm_samples; /* Current pcm sample count written to
file so far. */
};
/**
* encoder may add some data to the end of the last and start of the next
* but must never yield when called so any encoding done should be absolutely
* minimal.
*/
struct enc_buffer_event_data
{
unsigned long flags; /* in: One or more of:
* CHUNKF_PRERECORD
* CHUNKF_END_FILE
* CHUNKF_START_FILE
*/
struct enc_chunk_hdr *pre_chunk; /* in: pointer to first prerecord
* chunk
*/
struct enc_chunk_hdr *chunk; /* in,out: chunk were split occurs -
* first chunk of start
*/
};
/** Callbacks called by encoder codec **/
/* parameters passed to encoder by enc_get_inputs */
struct enc_inputs
{
unsigned long sample_rate; /* out - pcm frequency */
int num_channels; /* out - number of audio channels */
int rec_mono_mode; /* out - how to create mono */
struct encoder_config *config; /* out - encoder settings */
};
void enc_get_inputs(struct enc_inputs *inputs);
/* parameters pass from encoder to enc_set_parameters */
struct enc_parameters
{
/* IN parameters */
int afmt; /* AFMT_* id - sanity checker */
size_t chunk_size; /* max chunk size required */
unsigned long enc_sample_rate; /* actual sample rate used by encoder
(for recorded time calculation) */
size_t reserve_bytes; /* number of bytes to reserve immediately
following chunks */
void (*events_callback)(enum enc_events event,
void *data); /* pointer to events callback */
/* OUT parameters */
unsigned char *enc_buffer; /* pointer to enc_buffer */
size_t buf_chunk_size; /* size of chunks in enc_buffer */
int num_chunks; /* number of chunks allotted to encoder */
unsigned char *reserve_buffer; /* pointer to reserve_bytes bytes */
};
/* set the encoder dimensions - called by encoder codec at initialization
and termination */
void enc_set_parameters(struct enc_parameters *params);
/* returns pointer to next write chunk in circular buffer */
struct enc_chunk_hdr * enc_get_chunk(void);
/* releases the current chunk into the available chunks */
void enc_finish_chunk(void);
#define PCM_MAX_FEED_SIZE 20000 /* max pcm size passed to encoder */
/* passes a pointer to next chunk of unprocessed wav data */
unsigned char * enc_get_pcm_data(size_t size);
/* puts some pcm data back in the queue */
size_t enc_unget_pcm_data(size_t size);
#endif /* ENC_BASE_H */
|
