/*
 * Copyright (C) 2003-2011 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.
 */

#include "config.h"
#include "filter/volume_filter_plugin.h"
#include "filter_plugin.h"
#include "filter_internal.h"
#include "filter_registry.h"
#include "conf.h"
#include "pcm_volume.h"
#include "audio_format.h"
#include "player_control.h"

#include <assert.h>
#include <string.h>

#include <libavutil/channel_layout.h>
#include <libavutil/frame.h>
#include <libavutil/samplefmt.h>

struct volume_filter {
	struct filter filter;

	/**
	 * The current volume, from 0 to #PCM_VOLUME_1.
	 */
	unsigned volume;

	struct audio_format audio_format;
};

static inline GQuark
volume_quark(void)
{
	return g_quark_from_static_string("pcm_volume");
}

static struct filter *
volume_filter_init(G_GNUC_UNUSED const struct config_param *param,
		   G_GNUC_UNUSED GError **error_r)
{
	struct volume_filter *filter = g_new(struct volume_filter, 1);

	filter_init(&filter->filter, &volume_filter_plugin);
	filter->volume = PCM_VOLUME_1;

	return &filter->filter;
}

static void
volume_filter_finish(struct filter *filter)
{
	g_free(filter);
}

static const struct audio_format *
volume_filter_open(struct filter *_filter, struct audio_format *audio_format,
		   G_GNUC_UNUSED GError **error_r)
{
	struct volume_filter *filter = (struct volume_filter *)_filter;

	filter->audio_format = *audio_format;

	return &filter->audio_format;
}

static AVFrame *volume_filter_filter(struct filter *_filter, AVFrame *src)
{
	struct volume_filter *filter = (struct volume_filter *)_filter;
    int planar = av_sample_fmt_is_planar(src->format);
    int planes = planar ? av_get_channel_layout_nb_channels(src->channel_layout) : 1;
    int ret, i;

    /* optimized special case: 100% volume = no-op */
    if (filter->volume == PCM_VOLUME_1)
        return src;

    /* optimized special case: 0% volume = memset(0) */
    if (filter->volume <= 0) {
        AVFrame *dst = av_frame_alloc();
        if (!dst) {
            av_frame_free(&src);
            return NULL;
        }

        dst->nb_samples     = src->nb_samples;
        dst->format         = src->format;
        dst->channel_layout = src->channel_layout;
        av_frame_copy_props(dst, src);
        av_frame_free(&src);

        ret = av_frame_get_buffer(dst, 32);
        if (ret < 0)
            return NULL;

        av_samples_set_silence(dst->extended_data, 0, dst->nb_samples,
                               av_get_channel_layout_nb_channels(dst->channel_layout),
                               dst->format);
        return dst;
    }

    ret = av_frame_make_writable(src);
    if (ret < 0) {
        av_frame_free(&src);
        return NULL;
    }

    for (i = 0; i < planes; i++) {
        ret = pcm_volume(src->extended_data[i], src->linesize[0],
                         av_get_packed_sample_fmt(filter->audio_format.format),
                         filter->volume);
        if (!ret) {
            g_warning("pcm_volume() has failed");
            av_frame_free(&src);
            return NULL;
        }
    }

    return src;
}

const struct filter_plugin volume_filter_plugin = {
	.name = "volume",
	.init = volume_filter_init,
	.finish = volume_filter_finish,
	.open = volume_filter_open,
	.filter = volume_filter_filter,
};

unsigned
volume_filter_get(const struct filter *_filter)
{
	const struct volume_filter *filter =
		(const struct volume_filter *)_filter;

	assert(filter->filter.plugin == &volume_filter_plugin);
	assert(filter->volume <= PCM_VOLUME_1);

	return filter->volume;
}

void
volume_filter_set(struct filter *_filter, unsigned volume)
{
	struct volume_filter *filter = (struct volume_filter *)_filter;

	assert(filter->filter.plugin == &volume_filter_plugin);
	assert(volume <= PCM_VOLUME_1);

	filter->volume = volume;
}