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
|
/*
Copyright (C) 2004 Allan Sandfeld Jensen <kde@carewolf.com>
Copyright (C) 2005 Benjamin Meyer <ben at meyerhome dot net>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "encoderflac.h"
#ifdef HAVE_LIBFLAC
#include <FLAC/format.h>
#include <FLAC/metadata.h>
#include <FLAC/stream_encoder.h>
#include <kconfig.h>
#include <kdebug.h>
#if !defined FLAC_API_VERSION_CURRENT || FLAC_API_VERSION_CURRENT < 8
#define LEGACY_FLAC
#else
#undef LEGACY_FLAC
#endif
extern "C"
{
KDE_EXPORT void create_audiocd_encoders(KIO::SlaveBase *slave, TQPtrList<AudioCDEncoder> &encoders)
{
encoders.append(new EncoderFLAC(slave));
}
}
class EncoderFLAC::Private {
public:
FLAC__StreamEncoder *encoder;
FLAC__StreamMetadata** metadata;
KIO::SlaveBase* ioslave;
unsigned long data;
};
#ifdef LEGACY_FLAC
static FLAC__StreamEncoderWriteStatus WriteCallback(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data)
#else
static FLAC__StreamEncoderWriteStatus WriteCallback(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
#endif
{
EncoderFLAC::Private *d = (EncoderFLAC::Private*)client_data;
d->data += bytes;
TQByteArray output;
if (bytes) {
output.setRawData((const char*)buffer, bytes);
d->ioslave->data(output);
output.resetRawData((const char*)buffer, bytes);
}
return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
}
static void MetadataCallback (const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
{
// We do not have seekable writeback so we just discard the updated metadata
}
/*
static FLAC__SeekableStreamEncoderSeekStatus SeekCallback(const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
{} ; */
EncoderFLAC::EncoderFLAC(KIO::SlaveBase *slave) : AudioCDEncoder(slave) {
d = new Private();
d->ioslave = slave;
d->encoder = 0;
}
EncoderFLAC::~EncoderFLAC() {
if (d->encoder) FLAC__stream_encoder_delete(d->encoder);
delete d;
}
bool EncoderFLAC::init(){
d->encoder = FLAC__stream_encoder_new();
d->metadata = 0;
d->data = 0;
return true;
}
void EncoderFLAC::loadSettings() {
// config->setGroup("FLAC");
}
// Estimate size to be 5/8 of uncompresed size.
unsigned long EncoderFLAC::size(long time_secs) const {
long uncompressed = (time_secs * (44100*2*2));
return (uncompressed/8)*5 + 1000;
}
long EncoderFLAC::readInit(long size) {
kdDebug(7117) << "EncoderFLAC::readInit() called"<< endl;
d->data = 0;
#ifdef LEGACY_FLAC
FLAC__stream_encoder_set_write_callback(d->encoder, WriteCallback);
FLAC__stream_encoder_set_metadata_callback(d->encoder, MetadataCallback);
FLAC__stream_encoder_set_client_data(d->encoder, d);
#endif
// The options match approximely those of flac compression-level-3
FLAC__stream_encoder_set_do_mid_side_stereo(d->encoder, true);
FLAC__stream_encoder_set_loose_mid_side_stereo(d->encoder, true); // flac -M
FLAC__stream_encoder_set_max_lpc_order(d->encoder, 6); // flac -l6
FLAC__stream_encoder_set_min_residual_partition_order(d->encoder, 3);
FLAC__stream_encoder_set_max_residual_partition_order(d->encoder, 3); // flac -r3,3
FLAC__stream_encoder_set_blocksize(d->encoder, 4608);
FLAC__stream_encoder_set_streamable_subset(d->encoder, true);
if (size > 0)
FLAC__stream_encoder_set_total_samples_estimate(d->encoder, size/4);
#ifdef LEGACY_FLAC
if(FLAC__stream_encoder_init(d->encoder) != FLAC__STREAM_ENCODER_OK)
; // really should handle an init failure
#else
if(FLAC__stream_encoder_init_stream(d->encoder, WriteCallback, NULL, NULL, MetadataCallback, d) != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
; // really should handle an init failure
#endif
return d->data;
}
long EncoderFLAC::read(int16_t * buf, int frames)
{
unsigned long olddata = d->data;
FLAC__int32 *buffer = new FLAC__int32[frames*2];
for(int i=0; i<frames*2;i++) {
buffer[i] = (FLAC__int32)buf[i];
}
bool res = FLAC__stream_encoder_process_interleaved (d->encoder, buffer, frames);
delete[] buffer;
return d->data - olddata;
}
long EncoderFLAC::readCleanup()
{
FLAC__stream_encoder_finish(d->encoder);
// FLAC__stream_encoder_delete(d->encoder);
if (d->metadata) {
FLAC__metadata_object_delete(d->metadata[0]);
delete[] d->metadata;
d->metadata = 0;
}
return 0;
}
void EncoderFLAC::fillSongInfo( KCDDB::CDInfo info, int track, const TQString &comment )
{
d->metadata = new FLAC__StreamMetadata*[1];
d->metadata[0] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
// d->metadata[1] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
// d->metadata[2] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE)
typedef QPair<TQString, TQVariant> Comment;
Comment comments[7] = { Comment("Title", info.trackInfoList[track].get("title")),
Comment("Artist", info.get("artist")),
Comment("Album", info.get("title")),
Comment("Genre", info.get("genre")),
Comment("Tracknumber", TQString::number(track+1)),
Comment("Comment", comment),
Comment("Date", TQString::null )};
if (info.get("Year").toInt() > 0) {
TQDateTime dt(TQDate(info.get("Year").toInt(), 1, 1));
comments[6] = Comment("Date", dt.toString(Qt::ISODate));
}
FLAC__StreamMetadata_VorbisComment_Entry entry;
TQString field;
TQCString cfield;
int num_comments = 0;
for(int i=0; i<7; i++) {
if (!comments[i].second.toString().isEmpty()) {
field = comments[i].first+"="+comments[i].second.toString();
cfield = field.utf8();
entry.entry = (FLAC__byte*)qstrdup(cfield);
entry.length = cfield.length();
// Insert in vorbiscomment and assign ownership of pointers to FLAC
FLAC__metadata_object_vorbiscomment_insert_comment(d->metadata[0], num_comments, entry, false);
num_comments++;
}
}
FLAC__stream_encoder_set_metadata(d->encoder, d->metadata, 1);
}
#endif // HAVE_LIBFLAC
|
