Subversion Repositories Kolibri OS

/*

 * Copyright (c) 2012 Justin Ruggles 

 *

 * 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/mem.h"

#include "audio_data.h"

static const AVClass audio_data_class = {

    .class_name = "AudioData",

    .item_name  = av_default_item_name,

    .version    = LIBAVUTIL_VERSION_INT,

};

/*

 * Calculate alignment for data pointers.

 */

static void calc_ptr_alignment(AudioData *a)

{

    int p;

    int min_align = 128;

    for (p = 0; p < a->planes; p++) {

        int cur_align = 128;

        while ((intptr_t)a->data[p] % cur_align)

            cur_align >>= 1;

        if (cur_align < min_align)

            min_align = cur_align;

    }

    a->ptr_align = min_align;

}

int ff_audio_data_set_channels(AudioData *a, int channels)

{

    if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS ||

        channels > a->allocated_channels)

        return AVERROR(EINVAL);

    a->channels  = channels;

    a->planes    = a->is_planar ? channels : 1;

    calc_ptr_alignment(a);

    return 0;

}

int ff_audio_data_init(AudioData *a, uint8_t **src, int plane_size, int channels,

                       int nb_samples, enum AVSampleFormat sample_fmt,

                       int read_only, const char *name)

{

    int p;

    memset(a, 0, sizeof(*a));

    a->class = &audio_data_class;

    if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS) {

        av_log(a, AV_LOG_ERROR, "invalid channel count: %d\n", channels);

        return AVERROR(EINVAL);

    }

    a->sample_size = av_get_bytes_per_sample(sample_fmt);

    if (!a->sample_size) {

        av_log(a, AV_LOG_ERROR, "invalid sample format\n");

        return AVERROR(EINVAL);

    }

    a->is_planar = av_sample_fmt_is_planar(sample_fmt);

    a->planes    = a->is_planar ? channels : 1;

    a->stride    = a->sample_size * (a->is_planar ? 1 : channels);

    for (p = 0; p < (a->is_planar ? channels : 1); p++) {

        if (!src[p]) {

            av_log(a, AV_LOG_ERROR, "invalid NULL pointer for src[%d]\n", p);

            return AVERROR(EINVAL);

        }

        a->data[p] = src[p];

    }

    a->allocated_samples  = nb_samples * !read_only;

    a->nb_samples         = nb_samples;

    a->sample_fmt         = sample_fmt;

    a->channels           = channels;

    a->allocated_channels = channels;

    a->read_only          = read_only;

    a->allow_realloc      = 0;

    a->name               = name ? name : "{no name}";

    calc_ptr_alignment(a);

    a->samples_align = plane_size / a->stride;

    return 0;

}

AudioData *ff_audio_data_alloc(int channels, int nb_samples,

                               enum AVSampleFormat sample_fmt, const char *name)

{

    AudioData *a;

    int ret;

    if (channels < 1 || channels > AVRESAMPLE_MAX_CHANNELS)

        return NULL;

    a = av_mallocz(sizeof(*a));

    if (!a)

        return NULL;

    a->sample_size = av_get_bytes_per_sample(sample_fmt);

    if (!a->sample_size) {

        av_free(a);

        return NULL;

    }

    a->is_planar = av_sample_fmt_is_planar(sample_fmt);

    a->planes    = a->is_planar ? channels : 1;

    a->stride    = a->sample_size * (a->is_planar ? 1 : channels);

    a->class              = &audio_data_class;

    a->sample_fmt         = sample_fmt;

    a->channels           = channels;

    a->allocated_channels = channels;

    a->read_only          = 0;

    a->allow_realloc      = 1;

    a->name               = name ? name : "{no name}";

    if (nb_samples > 0) {

        ret = ff_audio_data_realloc(a, nb_samples);

        if (ret < 0) {

            av_free(a);

            return NULL;

        }

        return a;

    } else {

        calc_ptr_alignment(a);

        return a;

    }

}

int ff_audio_data_realloc(AudioData *a, int nb_samples)

{

    int ret, new_buf_size, plane_size, p;

    /* check if buffer is already large enough */

    if (a->allocated_samples >= nb_samples)

        return 0;

    /* validate that the output is not read-only and realloc is allowed */

    if (a->read_only || !a->allow_realloc)

        return AVERROR(EINVAL);

    new_buf_size = av_samples_get_buffer_size(&plane_size,

                                              a->allocated_channels, nb_samples,

                                              a->sample_fmt, 0);

    if (new_buf_size < 0)

        return new_buf_size;

    /* if there is already data in the buffer and the sample format is planar,

       allocate a new buffer and copy the data, otherwise just realloc the

       internal buffer and set new data pointers */

    if (a->nb_samples > 0 && a->is_planar) {

        uint8_t *new_data[AVRESAMPLE_MAX_CHANNELS] = { NULL };

        ret = av_samples_alloc(new_data, &plane_size, a->allocated_channels,

                               nb_samples, a->sample_fmt, 0);

        if (ret < 0)

            return ret;

        for (p = 0; p < a->planes; p++)

            memcpy(new_data[p], a->data[p], a->nb_samples * a->stride);

        av_freep(&a->buffer);

        memcpy(a->data, new_data, sizeof(new_data));

        a->buffer = a->data[0];

    } else {

        av_freep(&a->buffer);

        a->buffer = av_malloc(new_buf_size);

        if (!a->buffer)

            return AVERROR(ENOMEM);

        ret = av_samples_fill_arrays(a->data, &plane_size, a->buffer,

                                     a->allocated_channels, nb_samples,

                                     a->sample_fmt, 0);

        if (ret < 0)

            return ret;

    }

    a->buffer_size       = new_buf_size;

    a->allocated_samples = nb_samples;

    calc_ptr_alignment(a);

    a->samples_align = plane_size / a->stride;

    return 0;

}

void ff_audio_data_free(AudioData **a)

{

    if (!*a)

        return;

    av_free((*a)->buffer);

    av_freep(a);

}

int ff_audio_data_copy(AudioData *dst, AudioData *src, ChannelMapInfo *map)

{

    int ret, p;

    /* validate input/output compatibility */

    if (dst->sample_fmt != src->sample_fmt || dst->channels < src->channels)

        return AVERROR(EINVAL);

    if (map && !src->is_planar) {

        av_log(src, AV_LOG_ERROR, "cannot remap packed format during copy\n");

        return AVERROR(EINVAL);

    }

    /* if the input is empty, just empty the output */

    if (!src->nb_samples) {

        dst->nb_samples = 0;

        return 0;

    }

    /* reallocate output if necessary */

    ret = ff_audio_data_realloc(dst, src->nb_samples);

    if (ret < 0)

        return ret;

    /* copy data */

    if (map) {

        if (map->do_remap) {

            for (p = 0; p < src->planes; p++) {

                if (map->channel_map[p] >= 0)

                    memcpy(dst->data[p], src->data[map->channel_map[p]],

                           src->nb_samples * src->stride);

            }

        }

        if (map->do_copy || map->do_zero) {

            for (p = 0; p < src->planes; p++) {

                if (map->channel_copy[p])

                    memcpy(dst->data[p], dst->data[map->channel_copy[p]],

                           src->nb_samples * src->stride);

                else if (map->channel_zero[p])

                    av_samples_set_silence(&dst->data[p], 0, src->nb_samples,

                                           1, dst->sample_fmt);

            }

        }

    } else {

        for (p = 0; p < src->planes; p++)

            memcpy(dst->data[p], src->data[p], src->nb_samples * src->stride);

    }

    dst->nb_samples = src->nb_samples;

    return 0;

}

int ff_audio_data_combine(AudioData *dst, int dst_offset, AudioData *src,

                          int src_offset, int nb_samples)

{

    int ret, p, dst_offset2, dst_move_size;

    /* validate input/output compatibility */

    if (dst->sample_fmt != src->sample_fmt || dst->channels != src->channels) {

        av_log(src, AV_LOG_ERROR, "sample format mismatch\n");

        return AVERROR(EINVAL);

    }

    /* validate offsets are within the buffer bounds */

    if (dst_offset < 0 || dst_offset > dst->nb_samples ||

        src_offset < 0 || src_offset > src->nb_samples) {

        av_log(src, AV_LOG_ERROR, "offset out-of-bounds: src=%d dst=%d\n",

               src_offset, dst_offset);

        return AVERROR(EINVAL);

    }

    /* check offsets and sizes to see if we can just do nothing and return */

    if (nb_samples > src->nb_samples - src_offset)

        nb_samples = src->nb_samples - src_offset;

    if (nb_samples <= 0)

        return 0;

    /* validate that the output is not read-only */

    if (dst->read_only) {

        av_log(dst, AV_LOG_ERROR, "dst is read-only\n");

        return AVERROR(EINVAL);

    }

    /* reallocate output if necessary */

    ret = ff_audio_data_realloc(dst, dst->nb_samples + nb_samples);

    if (ret < 0) {

        av_log(dst, AV_LOG_ERROR, "error reallocating dst\n");

        return ret;

    }

    dst_offset2   = dst_offset + nb_samples;

    dst_move_size = dst->nb_samples - dst_offset;

    for (p = 0; p < src->planes; p++) {

        if (dst_move_size > 0) {

            memmove(dst->data[p] + dst_offset2 * dst->stride,

                    dst->data[p] + dst_offset  * dst->stride,

                    dst_move_size * dst->stride);

        }

        memcpy(dst->data[p] + dst_offset * dst->stride,

               src->data[p] + src_offset * src->stride,

               nb_samples * src->stride);

    }

    dst->nb_samples += nb_samples;

    return 0;

}

void ff_audio_data_drain(AudioData *a, int nb_samples)

{

    if (a->nb_samples <= nb_samples) {

        /* drain the whole buffer */

        a->nb_samples = 0;

    } else {

        int p;

        int move_offset = a->stride * nb_samples;

        int move_size   = a->stride * (a->nb_samples - nb_samples);

        for (p = 0; p < a->planes; p++)

            memmove(a->data[p], a->data[p] + move_offset, move_size);

        a->nb_samples -= nb_samples;

    }

}

int ff_audio_data_add_to_fifo(AVAudioFifo *af, AudioData *a, int offset,

                              int nb_samples)

{

    uint8_t *offset_data[AVRESAMPLE_MAX_CHANNELS];

    int offset_size, p;

    if (offset >= a->nb_samples)

        return 0;

    offset_size = offset * a->stride;

    for (p = 0; p < a->planes; p++)

        offset_data[p] = a->data[p] + offset_size;

    return av_audio_fifo_write(af, (void **)offset_data, nb_samples);

}

int ff_audio_data_read_from_fifo(AVAudioFifo *af, AudioData *a, int nb_samples)

{

    int ret;

    if (a->read_only)

        return AVERROR(EINVAL);

    ret = ff_audio_data_realloc(a, nb_samples);

    if (ret < 0)

        return ret;

    ret = av_audio_fifo_read(af, (void **)a->data, nb_samples);

    if (ret >= 0)

        a->nb_samples = ret;

    return ret;

}