oysteikt
/
mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

encoder/lame,twolame: convert to C++

This commit is contained in:
Max Kellermann 2013-07-30 08:52:47 +02:00
parent da1f4b3ede
commit 7a3aac1843
6 changed files with 162 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Makefile.am
View File

@ -662,11 +662,15 @@ libencoder_plugins_a_SOURCES += \
endif
if ENABLE_LAME_ENCODER
libencoder_plugins_a_SOURCES += src/encoder/lame_encoder.c
libencoder_plugins_a_SOURCES += \
src/encoder/LameEncoderPlugin.cxx \
src/encoder/LameEncoderPlugin.hxx
endif
if ENABLE_TWOLAME_ENCODER
libencoder_plugins_a_SOURCES += src/encoder/twolame_encoder.c
libencoder_plugins_a_SOURCES += \
src/encoder/TwolameEncoderPlugin.cxx \
src/encoder/TwolameEncoderPlugin.hxx
endif
if ENABLE_FLAC_ENCODER

5
src/EncoderList.cxx
View File

@ -25,12 +25,11 @@
#include "encoder/VorbisEncoderPlugin.hxx"
#include "encoder/OpusEncoderPlugin.hxx"
#include "encoder/FlacEncoderPlugin.hxx"
#include "encoder/LameEncoderPlugin.hxx"
#include "encoder/TwolameEncoderPlugin.hxx"
#include <string.h>
extern const struct encoder_plugin lame_encoder_plugin;
extern const struct encoder_plugin twolame_encoder_plugin;
const struct encoder_plugin *const encoder_plugins[] = {
&null_encoder_plugin,
#ifdef ENABLE_VORBIS_ENCODER

104
src/encoder/lame_encoder.c → src/encoder/LameEncoderPlugin.cxx
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2003-2011 The Music Player Daemon Project
* Copyright (C) 2003-2013 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
@ -18,6 +18,7 @@
*/
#include "config.h"
#include "LameEncoderPlugin.hxx"
#include "encoder_api.h"
#include "encoder_plugin.h"
#include "audio_format.h"
@ -29,7 +30,7 @@
#include <assert.h>
#include <string.h>
struct lame_encoder {
struct LameEncoder final {
struct encoder encoder;
struct audio_format audio_format;
@ -40,9 +41,13 @@ struct lame_encoder {
unsigned char buffer[32768];
size_t buffer_length;
};
extern const struct encoder_plugin lame_encoder_plugin;
LameEncoder() {
encoder_struct_init(&encoder, &lame_encoder_plugin);
}
bool Configure(const config_param *param, GError **error);
};
static inline GQuark
lame_encoder_quark(void)
@ -50,21 +55,19 @@ lame_encoder_quark(void)
return g_quark_from_static_string("lame_encoder");
}
static bool
lame_encoder_configure(struct lame_encoder *encoder,
const struct config_param *param, GError **error)
bool
LameEncoder::Configure(const config_param *param, GError **error)
{
const char *value;
char *endptr;
value = config_get_block_string(param, "quality", NULL);
if (value != NULL) {
value = config_get_block_string(param, "quality", nullptr);
if (value != nullptr) {
/* a quality was configured (VBR) */
encoder->quality = g_ascii_strtod(value, &endptr);
quality = g_ascii_strtod(value, &endptr);
if (*endptr != '\0' || encoder->quality < -1.0 ||
encoder->quality > 10.0) {
if (*endptr != '\0' || quality < -1.0 || quality > 10.0) {
g_set_error(error, lame_encoder_quark(), 0,
"quality \"%s\" is not a number in the "
"range -1 to 10, line %i",
@ -72,7 +75,7 @@ lame_encoder_configure(struct lame_encoder *encoder,
return false;
}
if (config_get_block_string(param, "bitrate", NULL) != NULL) {
if (config_get_block_string(param, "bitrate", nullptr) != nullptr) {
g_set_error(error, lame_encoder_quark(), 0,
"quality and bitrate are "
"both defined (line %i)",
@ -82,8 +85,8 @@ lame_encoder_configure(struct lame_encoder *encoder,
} else {
/* a bit rate was configured */
value = config_get_block_string(param, "bitrate", NULL);
if (value == NULL) {
value = config_get_block_string(param, "bitrate", nullptr);
if (value == nullptr) {
g_set_error(error, lame_encoder_quark(), 0,
"neither bitrate nor quality defined "
"at line %i",
@ -91,10 +94,10 @@ lame_encoder_configure(struct lame_encoder *encoder,
return false;
}
encoder->quality = -2.0;
encoder->bitrate = g_ascii_strtoll(value, &endptr, 10);
quality = -2.0;
bitrate = g_ascii_strtoll(value, &endptr, 10);
if (*endptr != '\0' || encoder->bitrate <= 0) {
if (*endptr != '\0' || bitrate <= 0) {
g_set_error(error, lame_encoder_quark(), 0,
"bitrate at line %i should be a positive integer",
param->line);
@ -106,18 +109,15 @@ lame_encoder_configure(struct lame_encoder *encoder,
}
static struct encoder *
lame_encoder_init(const struct config_param *param, GError **error)
lame_encoder_init(const struct config_param *param, GError **error_r)
{
struct lame_encoder *encoder;
encoder = g_new(struct lame_encoder, 1);
encoder_struct_init(&encoder->encoder, &lame_encoder_plugin);
LameEncoder *encoder = new LameEncoder();
/* load configuration from "param" */
if (!lame_encoder_configure(encoder, param, error)) {
if (!encoder->Configure(param, error_r)) {
/* configuration has failed, roll back and return error */
g_free(encoder);
return NULL;
delete encoder;
return nullptr;
}
return &encoder->encoder;
@ -126,7 +126,7 @@ lame_encoder_init(const struct config_param *param, GError **error)
static void
lame_encoder_finish(struct encoder *_encoder)
{
struct lame_encoder *encoder = (struct lame_encoder *)_encoder;
LameEncoder *encoder = (LameEncoder *)_encoder;
/* the real liblame cleanup was already performed by
lame_encoder_close(), so no real work here */
@ -134,7 +134,7 @@ lame_encoder_finish(struct encoder *_encoder)
}
static bool
lame_encoder_setup(struct lame_encoder *encoder, GError **error)
lame_encoder_setup(LameEncoder *encoder, GError **error)
{
if (encoder->quality >= -1.0) {
/* a quality was configured (VBR) */
@ -193,7 +193,7 @@ static bool
lame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
GError **error)
{
struct lame_encoder *encoder = (struct lame_encoder *)_encoder;
LameEncoder *encoder = (LameEncoder *)_encoder;
audio_format->format = SAMPLE_FORMAT_S16;
audio_format->channels = 2;
@ -201,7 +201,7 @@ lame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
encoder->audio_format = *audio_format;
encoder->gfp = lame_init();
if (encoder->gfp == NULL) {
if (encoder->gfp == nullptr) {
g_set_error(error, lame_encoder_quark(), 0,
"lame_init() failed");
return false;
@ -220,7 +220,7 @@ lame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
static void
lame_encoder_close(struct encoder *_encoder)
{
struct lame_encoder *encoder = (struct lame_encoder *)_encoder;
LameEncoder *encoder = (LameEncoder *)_encoder;
lame_close(encoder->gfp);
}
@ -230,30 +230,26 @@ lame_encoder_write(struct encoder *_encoder,
const void *data, size_t length,
gcc_unused GError **error)
{
struct lame_encoder *encoder = (struct lame_encoder *)_encoder;
unsigned num_frames;
float *left, *right;
LameEncoder *encoder = (LameEncoder *)_encoder;
const int16_t *src = (const int16_t*)data;
unsigned int i;
int bytes_out;
assert(encoder->buffer_length == 0);
num_frames =
const unsigned num_frames =
length / audio_format_frame_size(&encoder->audio_format);
left = g_malloc(sizeof(left[0]) * num_frames);
right = g_malloc(sizeof(right[0]) * num_frames);
float *left = g_new(float, num_frames);
float *right = g_new(float, num_frames);
/* this is for only 16-bit audio */
for (i = 0; i < num_frames; i++) {
for (unsigned i = 0; i < num_frames; i++) {
left[i] = *src++;
right[i] = *src++;
}
bytes_out = lame_encode_buffer_float(encoder->gfp, left, right,
num_frames, encoder->buffer,
sizeof(encoder->buffer));
int bytes_out = lame_encode_buffer_float(encoder->gfp, left, right,
num_frames, encoder->buffer,
sizeof(encoder->buffer));
g_free(left);
g_free(right);
@ -271,7 +267,7 @@ lame_encoder_write(struct encoder *_encoder,
static size_t
lame_encoder_read(struct encoder *_encoder, void *dest, size_t length)
{
struct lame_encoder *encoder = (struct lame_encoder *)_encoder;
LameEncoder *encoder = (LameEncoder *)_encoder;
if (length > encoder->buffer_length)
length = encoder->buffer_length;
@ -292,12 +288,16 @@ lame_encoder_get_mime_type(gcc_unused struct encoder *_encoder)
}
const struct encoder_plugin lame_encoder_plugin = {
.name = "lame",
.init = lame_encoder_init,
.finish = lame_encoder_finish,
.open = lame_encoder_open,
.close = lame_encoder_close,
.write = lame_encoder_write,
.read = lame_encoder_read,
.get_mime_type = lame_encoder_get_mime_type,
"lame",
lame_encoder_init,
lame_encoder_finish,
lame_encoder_open,
lame_encoder_close,
nullptr,
nullptr,
nullptr,
nullptr,
lame_encoder_write,
lame_encoder_read,
lame_encoder_get_mime_type,
};

25
src/encoder/LameEncoderPlugin.hxx Normal file
View File

@ -0,0 +1,25 @@
/*
* Copyright (C) 2003-2013 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_LAME_HXX
#define MPD_ENCODER_LAME_HXX
extern const struct encoder_plugin lame_encoder_plugin;
#endif

104
src/encoder/twolame_encoder.c → src/encoder/TwolameEncoderPlugin.cxx
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2003-2011 The Music Player Daemon Project
* Copyright (C) 2003-2013 The Music Player Daemon Project
* http://www.musicpd.org
*
* This program is free software; you can redistribute it and/or modify
@ -18,6 +18,7 @@
*/
#include "config.h"
#include "TwolameEncoderPlugin.hxx"
#include "encoder_api.h"
#include "encoder_plugin.h"
#include "audio_format.h"
@ -29,7 +30,7 @@
#include <assert.h>
#include <string.h>
struct twolame_encoder {
struct TwolameEncoder final {
struct encoder encoder;
struct audio_format audio_format;
@ -45,9 +46,13 @@ struct twolame_encoder {
* Call libtwolame's flush function when the buffer is empty?
*/
bool flush;
};
extern const struct encoder_plugin twolame_encoder_plugin;
TwolameEncoder() {
encoder_struct_init(&encoder, &twolame_encoder_plugin);
}
bool Configure(const config_param *param, GError **error);
};
static inline GQuark
twolame_encoder_quark(void)
@ -55,21 +60,19 @@ twolame_encoder_quark(void)
return g_quark_from_static_string("twolame_encoder");
}
static bool
twolame_encoder_configure(struct twolame_encoder *encoder,
const struct config_param *param, GError **error)
bool
TwolameEncoder::Configure(const config_param *param, GError **error)
{
const char *value;
char *endptr;
value = config_get_block_string(param, "quality", NULL);
if (value != NULL) {
value = config_get_block_string(param, "quality", nullptr);
if (value != nullptr) {
/* a quality was configured (VBR) */
encoder->quality = g_ascii_strtod(value, &endptr);
quality = g_ascii_strtod(value, &endptr);
if (*endptr != '\0' || encoder->quality < -1.0 ||
encoder->quality > 10.0) {
if (*endptr != '\0' || quality < -1.0 || quality > 10.0) {
g_set_error(error, twolame_encoder_quark(), 0,
"quality \"%s\" is not a number in the "
"range -1 to 10, line %i",
@ -77,7 +80,7 @@ twolame_encoder_configure(struct twolame_encoder *encoder,
return false;
}
if (config_get_block_string(param, "bitrate", NULL) != NULL) {
if (config_get_block_string(param, "bitrate", nullptr) != nullptr) {
g_set_error(error, twolame_encoder_quark(), 0,
"quality and bitrate are "
"both defined (line %i)",
@ -87,8 +90,8 @@ twolame_encoder_configure(struct twolame_encoder *encoder,
} else {
/* a bit rate was configured */
value = config_get_block_string(param, "bitrate", NULL);
if (value == NULL) {
value = config_get_block_string(param, "bitrate", nullptr);
if (value == nullptr) {
g_set_error(error, twolame_encoder_quark(), 0,
"neither bitrate nor quality defined "
"at line %i",
@ -96,10 +99,10 @@ twolame_encoder_configure(struct twolame_encoder *encoder,
return false;
}
encoder->quality = -2.0;
encoder->bitrate = g_ascii_strtoll(value, &endptr, 10);
quality = -2.0;
bitrate = g_ascii_strtoll(value, &endptr, 10);
if (*endptr != '\0' || encoder->bitrate <= 0) {
if (*endptr != '\0' || bitrate <= 0) {
g_set_error(error, twolame_encoder_quark(), 0,
"bitrate at line %i should be a positive integer",
param->line);
@ -111,20 +114,17 @@ twolame_encoder_configure(struct twolame_encoder *encoder,
}
static struct encoder *
twolame_encoder_init(const struct config_param *param, GError **error)
twolame_encoder_init(const struct config_param *param, GError **error_r)
{
struct twolame_encoder *encoder;
g_debug("libtwolame version %s", get_twolame_version());
encoder = g_new(struct twolame_encoder, 1);
encoder_struct_init(&encoder->encoder, &twolame_encoder_plugin);
TwolameEncoder *encoder = new TwolameEncoder();
/* load configuration from "param" */
if (!twolame_encoder_configure(encoder, param, error)) {
if (!encoder->Configure(param, error_r)) {
/* configuration has failed, roll back and return error */
g_free(encoder);
return NULL;
delete encoder;
return nullptr;
}
return &encoder->encoder;
@ -133,15 +133,15 @@ twolame_encoder_init(const struct config_param *param, GError **error)
static void
twolame_encoder_finish(struct encoder *_encoder)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
TwolameEncoder *encoder = (TwolameEncoder *)_encoder;
/* the real libtwolame cleanup was already performed by
twolame_encoder_close(), so no real work here */
g_free(encoder);
delete encoder;
}
static bool
twolame_encoder_setup(struct twolame_encoder *encoder, GError **error)
twolame_encoder_setup(TwolameEncoder *encoder, GError **error)
{
if (encoder->quality >= -1.0) {
/* a quality was configured (VBR) */
@ -193,7 +193,7 @@ static bool
twolame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
GError **error)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
TwolameEncoder *encoder = (TwolameEncoder *)_encoder;
audio_format->format = SAMPLE_FORMAT_S16;
audio_format->channels = 2;
@ -201,7 +201,7 @@ twolame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format
encoder->audio_format = *audio_format;
encoder->options = twolame_init();
if (encoder->options == NULL) {
if (encoder->options == nullptr) {
g_set_error(error, twolame_encoder_quark(), 0,
"twolame_init() failed");
return false;
@ -221,7 +221,7 @@ twolame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format
static void
twolame_encoder_close(struct encoder *_encoder)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
TwolameEncoder *encoder = (TwolameEncoder *)_encoder;
twolame_close(&encoder->options);
}
@ -229,7 +229,7 @@ twolame_encoder_close(struct encoder *_encoder)
static bool
twolame_encoder_flush(struct encoder *_encoder, gcc_unused GError **error)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
TwolameEncoder *encoder = (TwolameEncoder *)_encoder;
encoder->flush = true;
return true;
@ -240,20 +240,18 @@ twolame_encoder_write(struct encoder *_encoder,
const void *data, size_t length,
gcc_unused GError **error)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
unsigned num_frames;
TwolameEncoder *encoder = (TwolameEncoder *)_encoder;
const int16_t *src = (const int16_t*)data;
int bytes_out;
assert(encoder->buffer_length == 0);
num_frames =
const unsigned num_frames =
length / audio_format_frame_size(&encoder->audio_format);
bytes_out = twolame_encode_buffer_interleaved(encoder->options,
src, num_frames,
encoder->buffer,
sizeof(encoder->buffer));
int bytes_out = twolame_encode_buffer_interleaved(encoder->options,
src, num_frames,
encoder->buffer,
sizeof(encoder->buffer));
if (bytes_out < 0) {
g_set_error(error, twolame_encoder_quark(), 0,
"twolame encoder failed");
@ -267,7 +265,7 @@ twolame_encoder_write(struct encoder *_encoder,
static size_t
twolame_encoder_read(struct encoder *_encoder, void *dest, size_t length)
{
struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
TwolameEncoder *encoder = (TwolameEncoder *)_encoder;
if (encoder->buffer_length == 0 && encoder->flush) {
int ret = twolame_encode_flush(encoder->options,
@ -298,14 +296,16 @@ twolame_encoder_get_mime_type(gcc_unused struct encoder *_encoder)
}
const struct encoder_plugin twolame_encoder_plugin = {
.name = "twolame",
.init = twolame_encoder_init,
.finish = twolame_encoder_finish,
.open = twolame_encoder_open,
.close = twolame_encoder_close,
.end = twolame_encoder_flush,
.flush = twolame_encoder_flush,
.write = twolame_encoder_write,
.read = twolame_encoder_read,
.get_mime_type = twolame_encoder_get_mime_type,
"twolame",
twolame_encoder_init,
twolame_encoder_finish,
twolame_encoder_open,
twolame_encoder_close,
twolame_encoder_flush,
twolame_encoder_flush,
nullptr,
nullptr,
twolame_encoder_write,
twolame_encoder_read,
twolame_encoder_get_mime_type,
};

25
src/encoder/TwolameEncoderPlugin.hxx Normal file
View File

@ -0,0 +1,25 @@
/*
* Copyright (C) 2003-2013 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_TWOLAME_HXX
#define MPD_ENCODER_TWOLAME_HXX
extern const struct encoder_plugin twolame_encoder_plugin;
#endif