Subversion Repositories Kolibri OS

/*

 * This file is part of FFmpeg.

 *

 * FFmpeg 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.

 *

 * FFmpeg 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 FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#include 

#include 

#include "libavutil/attributes.h"

#include "libavutil/opt.h"

#include "libavutil/samplefmt.h"

#include "audio_frame_queue.h"

#include "avcodec.h"

#include "internal.h"

#define WV_DEFAULT_BLOCK_SIZE 32768

typedef struct LibWavpackContext {

    const AVClass *class;

    WavpackContext *wv;

    AudioFrameQueue afq;

    AVPacket *pkt;

    int user_size;

    int got_output;

} LibWavpackContext;

static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

                                const AVFrame *frame, int *got_output)

{

    LibWavpackContext *s = avctx->priv_data;

    int ret;

    s->got_output = 0;

    s->pkt        = pkt;

    s->user_size  = pkt->size;

    if (frame) {

        ret = ff_af_queue_add(&s->afq, frame);

        if (ret < 0)

            return ret;

        ret = WavpackPackSamples(s->wv, (int32_t*)frame->data[0], frame->nb_samples);

        if (!ret) {

            av_log(avctx, AV_LOG_ERROR, "Error encoding a frame: %s\n",

                   WavpackGetErrorMessage(s->wv));

            return AVERROR_UNKNOWN;

        }

    }

    if (!s->got_output &&

        (!frame || frame->nb_samples < avctx->frame_size)) {

        ret = WavpackFlushSamples(s->wv);

        if (!ret) {

            av_log(avctx, AV_LOG_ERROR, "Error flushing the encoder: %s\n",

                   WavpackGetErrorMessage(s->wv));

            return AVERROR_UNKNOWN;

        }

    }

    if (s->got_output) {

        ff_af_queue_remove(&s->afq, avctx->frame_size, &pkt->pts, &pkt->duration);

        *got_output = 1;

    }

    return 0;

}

static int encode_callback(void *id, void *data, int32_t count)

{

    AVCodecContext *avctx = id;

    LibWavpackContext *s  = avctx->priv_data;

    int ret, offset = s->pkt->size;

    if (s->user_size) {

        if (s->user_size - count < s->pkt->size) {

            av_log(avctx, AV_LOG_ERROR, "Provided packet too small.\n");

            return 0;

        }

        s->pkt->size += count;

    } else {

        ret = av_grow_packet(s->pkt, count);

        if (ret < 0) {

            av_log(avctx, AV_LOG_ERROR, "Error allocating output packet.\n");

            return 0;

        }

    }

    memcpy(s->pkt->data + offset, data, count);

    s->got_output = 1;

    return 1;

}

static av_cold int wavpack_encode_init(AVCodecContext *avctx)

{

    LibWavpackContext *s = avctx->priv_data;

    WavpackConfig config = { 0 };

    int ret;

    s->wv = WavpackOpenFileOutput(encode_callback, avctx, NULL);

    if (!s->wv) {

        av_log(avctx, AV_LOG_ERROR, "Error allocating the encoder.\n");

        return AVERROR(ENOMEM);

    }

    if (!avctx->frame_size)

        avctx->frame_size = WV_DEFAULT_BLOCK_SIZE;

    config.bytes_per_sample = 4;

    config.bits_per_sample  = 32;

    config.block_samples    = avctx->frame_size;

    config.channel_mask     = avctx->channel_layout;

    config.num_channels     = avctx->channels;

    config.sample_rate      = avctx->sample_rate;

    if (avctx->compression_level != FF_COMPRESSION_DEFAULT) {

        if (avctx->compression_level >= 3) {

            config.flags |= CONFIG_VERY_HIGH_FLAG;

            if      (avctx->compression_level >= 8)

                config.xmode = 6;

            else if (avctx->compression_level >= 7)

                config.xmode = 5;

            else if (avctx->compression_level >= 6)

                config.xmode = 4;

            else if (avctx->compression_level >= 5)

                config.xmode = 3;

            else if (avctx->compression_level >= 4)

                config.xmode = 2;

        } else if (avctx->compression_level >= 2)

            config.flags |= CONFIG_HIGH_FLAG;

        else if (avctx->compression_level < 1)

            config.flags |= CONFIG_FAST_FLAG;

    }

    ret = WavpackSetConfiguration(s->wv, &config, -1);

    if (!ret)

        goto fail;

    ret = WavpackPackInit(s->wv);

    if (!ret)

        goto fail;

    ff_af_queue_init(avctx, &s->afq);

    return 0;

fail:

    av_log(avctx, AV_LOG_ERROR, "Error configuring the encoder: %s.\n",

           WavpackGetErrorMessage(s->wv));

    WavpackCloseFile(s->wv);

    return AVERROR_UNKNOWN;

}

static av_cold int wavpack_encode_close(AVCodecContext *avctx)

{

    LibWavpackContext *s = avctx->priv_data;

    WavpackCloseFile(s->wv);

    ff_af_queue_close(&s->afq);

    return 0;

}

AVCodec ff_libwavpack_encoder = {

    .name           = "libwavpack",

    .type           = AVMEDIA_TYPE_AUDIO,

    .id             = AV_CODEC_ID_WAVPACK,

    .priv_data_size = sizeof(LibWavpackContext),

    .init           = wavpack_encode_init,

    .encode2        = wavpack_encode_frame,

    .close          = wavpack_encode_close,

    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_SMALL_LAST_FRAME,

    .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,

                                                     AV_SAMPLE_FMT_NONE },

};