gstreamer/subprojects/gst-plugins-bad/ext/openaptx/gstopenaptxenc.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

320 lines
9.7 KiB
C
Raw Normal View History

/* GStreamer openaptx audio encoder
*
* Copyright (C) 2020 Igor V. Kovalenko <igor.v.kovalenko@gmail.com>
* Copyright (C) 2020 Thomas Weißschuh <thomas@t-8ch.de>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* SECTION:element-openaptxenc
* @title: openaptxenc
*
* This element encodes raw S24LE integer stereo PCM audio into a Bluetooth aptX or aptX-HD stream.
* Accepts audio/aptx or audio/aptx-hd output streams.
*
* ## Example pipelines
* |[
* gst-launch-1.0 -v audiotestsrc ! openaptxenc ! avdec_aptx ! audioconvert ! autoaudiosink
* ]| Encode a sine wave into aptX, AV decode it and listen to result.
* |[
* gst-launch-1.0 -v audiotestsrc ! openaptxenc ! avdec_aptx_hd ! audioconvert ! autoaudiosink
* ]| Encode a sine wave into aptX-HD, AV decode it and listen to result.
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "gstopenaptxenc.h"
#include "openaptx-plugin.h"
GST_DEBUG_CATEGORY_STATIC (openaptx_enc_debug);
#define GST_CAT_DEFAULT openaptx_enc_debug
#define gst_openaptx_enc_parent_class parent_class
G_DEFINE_TYPE (GstOpenaptxEnc, gst_openaptx_enc, GST_TYPE_AUDIO_ENCODER);
GST_ELEMENT_REGISTER_DEFINE (openaptxenc, "openaptxenc", GST_RANK_NONE,
GST_TYPE_OPENAPTX_ENC);
static GstStaticPadTemplate openaptx_enc_sink_factory =
GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
GST_STATIC_CAPS ("audio/x-raw, format = S24LE,"
" rate = [ 1, MAX ], channels = 2, layout = interleaved"));
static GstStaticPadTemplate openaptx_enc_src_factory =
GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
GST_STATIC_CAPS ("audio/aptx-hd, channels = 2, rate = [ 1, MAX ]; "
"audio/aptx, channels = 2, rate = [ 1, MAX ]"));
static gboolean gst_openaptx_enc_start (GstAudioEncoder * enc);
static gboolean gst_openaptx_enc_stop (GstAudioEncoder * enc);
static gboolean gst_openaptx_enc_set_format (GstAudioEncoder * enc,
GstAudioInfo * info);
static GstFlowReturn gst_openaptx_enc_handle_frame (GstAudioEncoder * enc,
GstBuffer * buffer);
static gint64
gst_openaptx_enc_get_latency (GstOpenaptxEnc * enc, gint rate)
{
gint64 latency =
gst_util_uint64_scale (APTX_LATENCY_SAMPLES, GST_SECOND, rate);
GST_DEBUG_OBJECT (enc, "Latency: %" GST_TIME_FORMAT, GST_TIME_ARGS (latency));
return latency;
}
static gboolean
gst_openaptx_enc_set_format (GstAudioEncoder * audio_enc, GstAudioInfo * info)
{
GstOpenaptxEnc *enc = GST_OPENAPTX_ENC (audio_enc);
GstStructure *s;
GstCaps *caps, *output_caps = NULL;
gint rate;
gint64 encoder_latency;
gint ret;
rate = GST_AUDIO_INFO_RATE (info);
/* negotiate output format based on downstream caps restrictions */
caps = gst_pad_get_allowed_caps (GST_AUDIO_ENCODER_SRC_PAD (enc));
if (caps == NULL)
caps = gst_static_pad_template_get_caps (&openaptx_enc_src_factory);
else if (gst_caps_is_empty (caps))
goto failure;
/* let's see what is in the output caps */
s = gst_caps_get_structure (caps, 0);
enc->hd = gst_structure_has_name (s, "audio/aptx-hd");
gst_clear_caps (&caps);
output_caps = gst_caps_new_simple (enc->hd ? "audio/aptx-hd" : "audio/aptx",
"channels", G_TYPE_INT, APTX_NUM_CHANNELS,
"rate", G_TYPE_INT, rate, NULL);
GST_INFO_OBJECT (enc, "output caps %" GST_PTR_FORMAT, output_caps);
/* reinitialize codec */
if (enc->aptx_c)
aptx_finish (enc->aptx_c);
GST_INFO_OBJECT (enc, "Initialize %s codec", aptx_name (enc->hd));
enc->aptx_c = aptx_init (enc->hd);
encoder_latency = gst_openaptx_enc_get_latency (enc, rate);
gst_audio_encoder_set_latency (audio_enc, encoder_latency, encoder_latency);
/* we want to be handed all available samples in handle_frame, but always
* enough to encode a frame */
gst_audio_encoder_set_frame_samples_min (audio_enc, APTX_SAMPLES_PER_CHANNEL);
gst_audio_encoder_set_frame_samples_max (audio_enc, APTX_SAMPLES_PER_CHANNEL);
gst_audio_encoder_set_frame_max (audio_enc, 0);
/* FIXME: what to do with left-over samples at the end? can we encode them? */
gst_audio_encoder_set_hard_min (audio_enc, TRUE);
ret = gst_audio_encoder_set_output_format (audio_enc, output_caps);
gst_caps_unref (output_caps);
return ret;
failure:
if (output_caps)
gst_caps_unref (output_caps);
if (caps)
gst_caps_unref (caps);
return FALSE;
}
static GstFlowReturn
gst_openaptx_enc_handle_frame (GstAudioEncoder * audio_enc, GstBuffer * buffer)
{
GstOpenaptxEnc *enc = GST_OPENAPTX_ENC (audio_enc);
GstMapInfo out_map;
GstBuffer *outbuf = NULL;
GstFlowReturn ret;
guint frames;
gsize frame_len, output_size;
gssize processed = 0;
gsize written = 0;
/* fixed encoded frame size hd=0: LLRR, hd=1: LLLRRR */
frame_len = aptx_frame_size (enc->hd);
if (G_UNLIKELY (!buffer)) {
GST_DEBUG_OBJECT (enc, "Finish encoding");
frames = APTX_FINISH_FRAMES;
} else {
frames = gst_buffer_get_size (buffer) /
(APTX_SAMPLE_SIZE * APTX_SAMPLES_PER_FRAME);
if (frames == 0) {
GST_WARNING_OBJECT (enc, "Odd input stream size detected, skipping");
goto mixed_frames;
}
}
output_size = frames * frame_len;
outbuf = gst_audio_encoder_allocate_output_buffer (audio_enc, output_size);
if (outbuf == NULL)
goto no_output_buffer;
if (!gst_buffer_map (outbuf, &out_map, GST_MAP_WRITE)) {
gst_buffer_replace (&outbuf, NULL);
goto no_output_buffer_map;
}
if (G_LIKELY (buffer)) {
GstMapInfo in_map;
if (!gst_buffer_map (buffer, &in_map, GST_MAP_READ)) {
gst_buffer_unmap (outbuf, &out_map);
gst_buffer_replace (&outbuf, NULL);
goto map_failed;
}
GST_LOG_OBJECT (enc,
"encoding %" G_GSIZE_FORMAT " samples into %u %s frames",
in_map.size / (APTX_NUM_CHANNELS * APTX_SAMPLE_SIZE), frames,
aptx_name (enc->hd));
processed = aptx_encode (enc->aptx_c, in_map.data, in_map.size,
out_map.data, output_size, &written);
gst_buffer_unmap (buffer, &in_map);
} else {
aptx_encode_finish (enc->aptx_c, out_map.data, output_size, &written);
output_size = written;
}
if (processed < 0 || written != output_size) {
GST_WARNING_OBJECT (enc,
"%s encoding error, processed = %" G_GSSIZE_FORMAT ", "
"written = %" G_GSSIZE_FORMAT ", expected = %" G_GSIZE_FORMAT,
aptx_name (enc->hd), processed, written, frames * frame_len);
}
gst_buffer_unmap (outbuf, &out_map);
GST_LOG_OBJECT (enc, "%s written = %" G_GSSIZE_FORMAT,
aptx_name (enc->hd), written);
done:
if (G_LIKELY (outbuf)) {
if (G_LIKELY (written > 0))
gst_buffer_set_size (outbuf, written);
else
gst_buffer_replace (&outbuf, NULL);
}
ret = gst_audio_encoder_finish_frame (audio_enc, outbuf,
written / frame_len * APTX_SAMPLES_PER_CHANNEL);
if (G_UNLIKELY (!buffer))
ret = GST_FLOW_EOS;
return ret;
/* ERRORS */
mixed_frames:
{
GST_WARNING_OBJECT (enc, "inconsistent input data/frames, skipping");
goto done;
}
no_output_buffer_map:
{
GST_ELEMENT_ERROR (enc, RESOURCE, FAILED,
("Could not map output buffer"),
("Failed to map allocated output buffer for write access."));
return GST_FLOW_ERROR;
}
no_output_buffer:
{
GST_ELEMENT_ERROR (enc, RESOURCE, FAILED,
("Could not allocate output buffer"),
("Audio encoder failed to allocate output buffer to hold an audio frame."));
return GST_FLOW_ERROR;
}
map_failed:
{
GST_ELEMENT_ERROR (enc, RESOURCE, FAILED,
("Could not map input buffer"),
("Failed to map incoming buffer for read access."));
return GST_FLOW_ERROR;
}
}
static gboolean
gst_openaptx_enc_start (GstAudioEncoder * audio_enc)
{
return TRUE;
}
static gboolean
gst_openaptx_enc_stop (GstAudioEncoder * audio_enc)
{
GstOpenaptxEnc *enc = GST_OPENAPTX_ENC (audio_enc);
GST_INFO_OBJECT (enc, "Finish openaptx codec");
if (enc->aptx_c) {
aptx_finish (enc->aptx_c);
enc->aptx_c = NULL;
}
return TRUE;
}
static void
gst_openaptx_enc_class_init (GstOpenaptxEncClass * klass)
{
GstAudioEncoderClass *base_class = GST_AUDIO_ENCODER_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
base_class->start = GST_DEBUG_FUNCPTR (gst_openaptx_enc_start);
base_class->stop = GST_DEBUG_FUNCPTR (gst_openaptx_enc_stop);
base_class->set_format = GST_DEBUG_FUNCPTR (gst_openaptx_enc_set_format);
base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_openaptx_enc_handle_frame);
gst_element_class_add_static_pad_template (element_class,
&openaptx_enc_sink_factory);
gst_element_class_add_static_pad_template (element_class,
&openaptx_enc_src_factory);
gst_element_class_set_static_metadata (element_class,
"Bluetooth aptX/aptX-HD audio encoder using libopenaptx",
"Codec/Encoder/Audio",
"Encode an aptX or aptX-HD audio stream using libopenaptx",
"Igor V. Kovalenko <igor.v.kovalenko@gmail.com>, "
"Thomas Weißschuh <thomas@t-8ch.de>");
GST_DEBUG_CATEGORY_INIT (openaptx_enc_debug, "openaptxenc", 0,
"openaptx encoding element");
}
static void
gst_openaptx_enc_init (GstOpenaptxEnc * enc)
{
GST_PAD_SET_ACCEPT_TEMPLATE (GST_AUDIO_ENCODER_SINK_PAD (enc));
enc->aptx_c = NULL;
}