[deb_ffmpeg.git] / ffmpeg / libavfilter / formats.c

/*
 * Filter layer - format negotiation
 * Copyright (c) 2007 Bobby Bingham
 *
 * 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 "libavutil/avassert.h"
#include "libavutil/channel_layout.h"
#include "libavutil/common.h"
#include "libavutil/eval.h"
#include "libavutil/pixdesc.h"
#include "libavutil/parseutils.h"
#include "avfilter.h"
#include "internal.h"
#include "formats.h"

#define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */

/**
 * Add all refs from a to ret and destroy a.
 */
#define MERGE_REF(ret, a, fmts, type, fail)                                \
do {                                                                       \
    type ***tmp;                                                           \
    int i;                                                                 \
                                                                           \
    if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount,   \
                                 sizeof(*tmp))))                           \
        goto fail;                                                         \
    ret->refs = tmp;                                                       \
                                                                           \
    for (i = 0; i < a->refcount; i ++) {                                   \
        ret->refs[ret->refcount] = a->refs[i];                             \
        *ret->refs[ret->refcount++] = ret;                                 \
    }                                                                      \
                                                                           \
    av_freep(&a->refs);                                                    \
    av_freep(&a->fmts);                                                    \
    av_freep(&a);                                                          \
} while (0)

/**
 * Add all formats common for a and b to ret, copy the refs and destroy
 * a and b.
 */
#define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail)                          \
do {                                                                            \
    int i, j, k = 0, count = FFMIN(a->nb, b->nb);                               \
                                                                                \
    if (!(ret = av_mallocz(sizeof(*ret))))                                      \
        goto fail;                                                              \
                                                                                \
    if (count) {                                                                \
        if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts))))          \
            goto fail;                                                          \
        for (i = 0; i < a->nb; i++)                                             \
            for (j = 0; j < b->nb; j++)                                         \
                if (a->fmts[i] == b->fmts[j]) {                                 \
                    if(k >= FFMIN(a->nb, b->nb)){                               \
                        av_log(NULL, AV_LOG_ERROR, "Duplicate formats in avfilter_merge_formats() detected\n"); \
                        av_free(ret->fmts);                                     \
                        av_free(ret);                                           \
                        return NULL;                                            \
                    }                                                           \
                    ret->fmts[k++] = a->fmts[i];                                \
                }                                                               \
    }                                                                           \
    ret->nb = k;                                                                \
    /* check that there was at least one common format */                       \
    if (!ret->nb)                                                               \
        goto fail;                                                              \
                                                                                \
    MERGE_REF(ret, a, fmts, type, fail);                                        \
    MERGE_REF(ret, b, fmts, type, fail);                                        \
} while (0)

AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,
                                  enum AVMediaType type)
{
    AVFilterFormats *ret = NULL;
    int i, j;
    int alpha1=0, alpha2=0;
    int chroma1=0, chroma2=0;

    if (a == b)
        return a;

    /* Do not lose chroma or alpha in merging.
       It happens if both lists have formats with chroma (resp. alpha), but
       the only formats in common do not have it (e.g. YUV+gray vs.
       RGB+gray): in that case, the merging would select the gray format,
       possibly causing a lossy conversion elsewhere in the graph.
       To avoid that, pretend that there are no common formats to force the
       insertion of a conversion filter. */
    if (type == AVMEDIA_TYPE_VIDEO)
        for (i = 0; i < a->nb_formats; i++)
            for (j = 0; j < b->nb_formats; j++) {
                const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
                const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
                alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
                chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
                if (a->formats[i] == b->formats[j]) {
                    alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
                    chroma1|= adesc->nb_components > 1;
                }
            }

    // If chroma or alpha can be lost through merging then do not merge
    if (alpha2 > alpha1 || chroma2 > chroma1)
        return NULL;

    MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);

    return ret;
fail:
    if (ret) {
        av_freep(&ret->refs);
        av_freep(&ret->formats);
    }
    av_freep(&ret);
    return NULL;
}

AVFilterFormats *ff_merge_samplerates(AVFilterFormats *a,
                                      AVFilterFormats *b)
{
    AVFilterFormats *ret = NULL;

    if (a == b) return a;

    if (a->nb_formats && b->nb_formats) {
        MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
    } else if (a->nb_formats) {
        MERGE_REF(a, b, formats, AVFilterFormats, fail);
        ret = a;
    } else {
        MERGE_REF(b, a, formats, AVFilterFormats, fail);
        ret = b;
    }

    return ret;
fail:
    if (ret) {
        av_freep(&ret->refs);
        av_freep(&ret->formats);
    }
    av_freep(&ret);
    return NULL;
}

AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a,
                                                 AVFilterChannelLayouts *b)
{
    AVFilterChannelLayouts *ret = NULL;
    unsigned a_all = a->all_layouts + a->all_counts;
    unsigned b_all = b->all_layouts + b->all_counts;
    int ret_max, ret_nb = 0, i, j, round;

    if (a == b) return a;

    /* Put the most generic set in a, to avoid doing everything twice */
    if (a_all < b_all) {
        FFSWAP(AVFilterChannelLayouts *, a, b);
        FFSWAP(unsigned, a_all, b_all);
    }
    if (a_all) {
        if (a_all == 1 && !b_all) {
            /* keep only known layouts in b; works also for b_all = 1 */
            for (i = j = 0; i < b->nb_channel_layouts; i++)
                if (KNOWN(b->channel_layouts[i]))
                    b->channel_layouts[j++] = b->channel_layouts[i];
            /* Not optimal: the unknown layouts of b may become known after
               another merge. */
            if (!j)
                return NULL;
            b->nb_channel_layouts = j;
        }
        MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
        return b;
    }

    ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
    if (!(ret = av_mallocz(sizeof(*ret))) ||
        !(ret->channel_layouts = av_malloc_array(ret_max,
                                                 sizeof(*ret->channel_layouts))))
        goto fail;

    /* a[known] intersect b[known] */
    for (i = 0; i < a->nb_channel_layouts; i++) {
        if (!KNOWN(a->channel_layouts[i]))
            continue;
        for (j = 0; j < b->nb_channel_layouts; j++) {
            if (a->channel_layouts[i] == b->channel_layouts[j]) {
                ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
                a->channel_layouts[i] = b->channel_layouts[j] = 0;
            }
        }
    }
    /* 1st round: a[known] intersect b[generic]
       2nd round: a[generic] intersect b[known] */
    for (round = 0; round < 2; round++) {
        for (i = 0; i < a->nb_channel_layouts; i++) {
            uint64_t fmt = a->channel_layouts[i], bfmt;
            if (!fmt || !KNOWN(fmt))
                continue;
            bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));
            for (j = 0; j < b->nb_channel_layouts; j++)
                if (b->channel_layouts[j] == bfmt)
                    ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
        }
        /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
        FFSWAP(AVFilterChannelLayouts *, a, b);
    }
    /* a[generic] intersect b[generic] */
    for (i = 0; i < a->nb_channel_layouts; i++) {
        if (KNOWN(a->channel_layouts[i]))
            continue;
        for (j = 0; j < b->nb_channel_layouts; j++)
            if (a->channel_layouts[i] == b->channel_layouts[j])
                ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
    }

    ret->nb_channel_layouts = ret_nb;
    if (!ret->nb_channel_layouts)
        goto fail;
    MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
    MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);
    return ret;

fail:
    if (ret) {
        av_freep(&ret->refs);
        av_freep(&ret->channel_layouts);
    }
    av_freep(&ret);
    return NULL;
}

int ff_fmt_is_in(int fmt, const int *fmts)
{
    const int *p;

    for (p = fmts; *p != -1; p++) {
        if (fmt == *p)
            return 1;
    }
    return 0;
}

#define COPY_INT_LIST(list_copy, list, type) {                          \
    int count = 0;                                                      \
    if (list)                                                           \
        for (count = 0; list[count] != -1; count++)                     \
            ;                                                           \
    list_copy = av_calloc(count+1, sizeof(type));                       \
    if (list_copy) {                                                    \
        memcpy(list_copy, list, sizeof(type) * count);                  \
        list_copy[count] = -1;                                          \
    }                                                                   \
}

#define MAKE_FORMAT_LIST(type, field, count_field)                      \
    type *formats;                                                      \
    int count = 0;                                                      \
    if (fmts)                                                           \
        for (count = 0; fmts[count] != -1; count++)                     \
            ;                                                           \
    formats = av_mallocz(sizeof(*formats));                             \
    if (!formats) return NULL;                                          \
    formats->count_field = count;                                       \
    if (count) {                                                        \
        formats->field = av_malloc_array(count, sizeof(*formats->field));      \
        if (!formats->field) {                                          \
            av_free(formats);                                           \
            return NULL;                                                \
        }                                                               \
    }

AVFilterFormats *ff_make_format_list(const int *fmts)
{
    MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
    while (count--)
        formats->formats[count] = fmts[count];

    return formats;
}

AVFilterChannelLayouts *avfilter_make_format64_list(const int64_t *fmts)
{
    MAKE_FORMAT_LIST(AVFilterChannelLayouts,
                     channel_layouts, nb_channel_layouts);
    if (count)
        memcpy(formats->channel_layouts, fmts,
               sizeof(*formats->channel_layouts) * count);

    return formats;
}

#define ADD_FORMAT(f, fmt, type, list, nb)                  \
do {                                                        \
    type *fmts;                                             \
    void *oldf = *f;                                        \
                                                            \
    if (!(*f) && !(*f = av_mallocz(sizeof(**f))))           \
        return AVERROR(ENOMEM);                             \
                                                            \
    fmts = av_realloc((*f)->list,                           \
                      sizeof(*(*f)->list) * ((*f)->nb + 1));\
    if (!fmts) {                                            \
        if (!oldf)                                          \
            av_freep(f);                                    \
        return AVERROR(ENOMEM);                             \
    }                                                       \
                                                            \
    (*f)->list = fmts;                                      \
    (*f)->list[(*f)->nb++] = fmt;                           \
} while (0)

int ff_add_format(AVFilterFormats **avff, int64_t fmt)
{
    ADD_FORMAT(avff, fmt, int, formats, nb_formats);
    return 0;
}

int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
{
    av_assert1(!(*l && (*l)->all_layouts));
    ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
    return 0;
}

AVFilterFormats *ff_all_formats(enum AVMediaType type)
{
    AVFilterFormats *ret = NULL;

    if (type == AVMEDIA_TYPE_VIDEO) {
        const AVPixFmtDescriptor *desc = NULL;
        while ((desc = av_pix_fmt_desc_next(desc))) {
            if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
                ff_add_format(&ret, av_pix_fmt_desc_get_id(desc));
        }
    } else if (type == AVMEDIA_TYPE_AUDIO) {
        enum AVSampleFormat fmt = 0;
        while (av_get_sample_fmt_name(fmt)) {
            ff_add_format(&ret, fmt);
            fmt++;
        }
    }

    return ret;
}

const int64_t avfilter_all_channel_layouts[] = {
#include "all_channel_layouts.inc"
    -1
};

// AVFilterFormats *avfilter_make_all_channel_layouts(void)
// {
//     return avfilter_make_format64_list(avfilter_all_channel_layouts);
// }

AVFilterFormats *ff_planar_sample_fmts(void)
{
    AVFilterFormats *ret = NULL;
    int fmt;

    for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
        if (av_sample_fmt_is_planar(fmt))
            ff_add_format(&ret, fmt);

    return ret;
}

AVFilterFormats *ff_all_samplerates(void)
{
    AVFilterFormats *ret = av_mallocz(sizeof(*ret));
    return ret;
}

AVFilterChannelLayouts *ff_all_channel_layouts(void)
{
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
    if (!ret)
        return NULL;
    ret->all_layouts = 1;
    return ret;
}

AVFilterChannelLayouts *ff_all_channel_counts(void)
{
    AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
    if (!ret)
        return NULL;
    ret->all_layouts = ret->all_counts = 1;
    return ret;
}

#define FORMATS_REF(f, ref)                                          \
do {                                                                 \
    *ref = f;                                                        \
    f->refs = av_realloc(f->refs, sizeof(*f->refs) * ++f->refcount); \
    f->refs[f->refcount-1] = ref;                                    \
} while (0)

void ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
{
    FORMATS_REF(f, ref);
}

void ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
{
    FORMATS_REF(f, ref);
}

#define FIND_REF_INDEX(ref, idx)            \
do {                                        \
    int i;                                  \
    for (i = 0; i < (*ref)->refcount; i ++) \
        if((*ref)->refs[i] == ref) {        \
            idx = i;                        \
            break;                          \
        }                                   \
} while (0)

#define FORMATS_UNREF(ref, list)                                   \
do {                                                               \
    int idx = -1;                                                  \
                                                                   \
    if (!*ref)                                                     \
        return;                                                    \
                                                                   \
    FIND_REF_INDEX(ref, idx);                                      \
                                                                   \
    if (idx >= 0)                                                  \
        memmove((*ref)->refs + idx, (*ref)->refs + idx + 1,        \
            sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
                                                                   \
    if(!--(*ref)->refcount) {                                      \
        av_free((*ref)->list);                                     \
        av_free((*ref)->refs);                                     \
        av_free(*ref);                                             \
    }                                                              \
    *ref = NULL;                                                   \
} while (0)

void ff_formats_unref(AVFilterFormats **ref)
{
    FORMATS_UNREF(ref, formats);
}

void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
{
    FORMATS_UNREF(ref, channel_layouts);
}

#define FORMATS_CHANGEREF(oldref, newref)       \
do {                                            \
    int idx = -1;                               \
                                                \
    FIND_REF_INDEX(oldref, idx);                \
                                                \
    if (idx >= 0) {                             \
        (*oldref)->refs[idx] = newref;          \
        *newref = *oldref;                      \
        *oldref = NULL;                         \
    }                                           \
} while (0)

void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
                                  AVFilterChannelLayouts **newref)
{
    FORMATS_CHANGEREF(oldref, newref);
}

void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
{
    FORMATS_CHANGEREF(oldref, newref);
}

#define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
if (fmts) {                                                         \
    int count = 0, i;                                               \
                                                                    \
    for (i = 0; i < ctx->nb_inputs; i++) {                          \
        if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) {          \
            ref(fmts, &ctx->inputs[i]->out_fmts);                   \
            count++;                                                \
        }                                                           \
    }                                                               \
    for (i = 0; i < ctx->nb_outputs; i++) {                         \
        if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) {         \
            ref(fmts, &ctx->outputs[i]->in_fmts);                   \
            count++;                                                \
        }                                                           \
    }                                                               \
                                                                    \
    if (!count) {                                                   \
        av_freep(&fmts->list);                                      \
        av_freep(&fmts->refs);                                      \
        av_freep(&fmts);                                            \
    }                                                               \
}

void ff_set_common_channel_layouts(AVFilterContext *ctx,
                                   AVFilterChannelLayouts *layouts)
{
    SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
                       ff_channel_layouts_ref, channel_layouts);
}

void ff_set_common_samplerates(AVFilterContext *ctx,
                               AVFilterFormats *samplerates)
{
    SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
                       ff_formats_ref, formats);
}

/**
 * A helper for query_formats() which sets all links to the same list of
 * formats. If there are no links hooked to this filter, the list of formats is
 * freed.
 */
void ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
{
    SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
                       ff_formats_ref, formats);
}

static int default_query_formats_common(AVFilterContext *ctx,
                                        AVFilterChannelLayouts *(layouts)(void))
{
    enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :
                            ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
                            AVMEDIA_TYPE_VIDEO;

    ff_set_common_formats(ctx, ff_all_formats(type));
    if (type == AVMEDIA_TYPE_AUDIO) {
        ff_set_common_channel_layouts(ctx, layouts());
        ff_set_common_samplerates(ctx, ff_all_samplerates());
    }

    return 0;
}

int ff_default_query_formats(AVFilterContext *ctx)
{
    return default_query_formats_common(ctx, ff_all_channel_layouts);
}

int ff_query_formats_all(AVFilterContext *ctx)
{
    return default_query_formats_common(ctx, ff_all_channel_counts);
}

/* internal functions for parsing audio format arguments */

int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
{
    char *tail;
    int pix_fmt = av_get_pix_fmt(arg);
    if (pix_fmt == AV_PIX_FMT_NONE) {
        pix_fmt = strtol(arg, &tail, 0);
        if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
            av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
            return AVERROR(EINVAL);
        }
    }
    *ret = pix_fmt;
    return 0;
}

int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
{
    char *tail;
    int sfmt = av_get_sample_fmt(arg);
    if (sfmt == AV_SAMPLE_FMT_NONE) {
        sfmt = strtol(arg, &tail, 0);
        if (*tail || av_get_bytes_per_sample(sfmt)<=0) {
            av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
            return AVERROR(EINVAL);
        }
    }
    *ret = sfmt;
    return 0;
}

int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
{
    AVRational r;
    if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0  ||r.den<=0) {
        av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
        return AVERROR(EINVAL);
    }
    *ret = r;
    return 0;
}

int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
{
    char *tail;
    double srate = av_strtod(arg, &tail);
    if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
        av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
        return AVERROR(EINVAL);
    }
    *ret = srate;
    return 0;
}

int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
                            void *log_ctx)
{
    char *tail;
    int64_t chlayout, count;

    if (nret) {
        count = strtol(arg, &tail, 10);
        if (*tail == 'c' && !tail[1] && count > 0 && count < 63) {
            *nret = count;
            *ret = 0;
            return 0;
        }
    }
    chlayout = av_get_channel_layout(arg);
    if (chlayout == 0) {
        chlayout = strtol(arg, &tail, 10);
        if (*tail || chlayout == 0) {
            av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
            return AVERROR(EINVAL);
        }
    }
    *ret = chlayout;
    if (nret)
        *nret = av_get_channel_layout_nb_channels(chlayout);
    return 0;
}

#ifdef TEST

#undef printf

int main(void)
{
    const int64_t *cl;
    char buf[512];

    for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
        av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
        printf("%s\n", buf);
    }

    return 0;
}

#endif
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Filter layer - format negotiation
	3	* Copyright (c) 2007 Bobby Bingham
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include "libavutil/avassert.h"
	23	#include "libavutil/channel_layout.h"
	24	#include "libavutil/common.h"
	25	#include "libavutil/eval.h"
	26	#include "libavutil/pixdesc.h"
	27	#include "libavutil/parseutils.h"
	28	#include "avfilter.h"
	29	#include "internal.h"
	30	#include "formats.h"
	31
	32	#define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */
	33
	34	/**
	35	* Add all refs from a to ret and destroy a.
	36	*/
	37	#define MERGE_REF(ret, a, fmts, type, fail) \
	38	do { \
	39	type ***tmp; \
	40	int i; \
	41	\
	42	if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
	43	sizeof(*tmp)))) \
	44	goto fail; \
	45	ret->refs = tmp; \
	46	\
	47	for (i = 0; i < a->refcount; i ++) { \
	48	ret->refs[ret->refcount] = a->refs[i]; \
	49	*ret->refs[ret->refcount++] = ret; \
	50	} \
	51	\
	52	av_freep(&a->refs); \
	53	av_freep(&a->fmts); \
	54	av_freep(&a); \
	55	} while (0)
	56
	57	/**
	58	* Add all formats common for a and b to ret, copy the refs and destroy
	59	* a and b.
	60	*/
	61	#define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \
	62	do { \
	63	int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
	64	\
65	if (!(ret = av_mallocz(sizeof(*ret)))) \
66	goto fail; \
67	\
68	if (count) { \
69	if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts)))) \
70	goto fail; \
71	for (i = 0; i < a->nb; i++) \
72	for (j = 0; j < b->nb; j++) \
73	if (a->fmts[i] == b->fmts[j]) { \
74	if(k >= FFMIN(a->nb, b->nb)){ \
75	av_log(NULL, AV_LOG_ERROR, "Duplicate formats in avfilter_merge_formats() detected\n"); \
76	av_free(ret->fmts); \
77	av_free(ret); \
78	return NULL; \
79	} \
80	ret->fmts[k++] = a->fmts[i]; \
81	} \
82	} \
83	ret->nb = k; \
84	/* check that there was at least one common format */ \
85	if (!ret->nb) \
86	goto fail; \
87	\
88	MERGE_REF(ret, a, fmts, type, fail); \
89	MERGE_REF(ret, b, fmts, type, fail); \
90	} while (0)
91
92	AVFilterFormats ff_merge_formats(AVFilterFormats a, AVFilterFormats *b,
93	enum AVMediaType type)
94	{
95	AVFilterFormats *ret = NULL;
96	int i, j;
97	int alpha1=0, alpha2=0;
98	int chroma1=0, chroma2=0;
99
100	if (a == b)
101	return a;
102
103	/* Do not lose chroma or alpha in merging.
104	It happens if both lists have formats with chroma (resp. alpha), but
105	the only formats in common do not have it (e.g. YUV+gray vs.
106	RGB+gray): in that case, the merging would select the gray format,
107	possibly causing a lossy conversion elsewhere in the graph.
108	To avoid that, pretend that there are no common formats to force the
109	insertion of a conversion filter. */
110	if (type == AVMEDIA_TYPE_VIDEO)
111	for (i = 0; i < a->nb_formats; i++)
112	for (j = 0; j < b->nb_formats; j++) {
113	const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
114	const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
115	alpha2 \|= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
116	chroma2\|= adesc->nb_components > 1 && bdesc->nb_components > 1;
117	if (a->formats[i] == b->formats[j]) {
118	alpha1 \|= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119	chroma1\|= adesc->nb_components > 1;
120	}
121	}
122
123	// If chroma or alpha can be lost through merging then do not merge
124	if (alpha2 > alpha1 \|\| chroma2 > chroma1)
125	return NULL;
126
127	MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
128
129	return ret;
130	fail:
131	if (ret) {
132	av_freep(&ret->refs);
133	av_freep(&ret->formats);
134	}
135	av_freep(&ret);
136	return NULL;
137	}
138
139	AVFilterFormats ff_merge_samplerates(AVFilterFormats a,
140	AVFilterFormats *b)
141	{
142	AVFilterFormats *ret = NULL;
143
144	if (a == b) return a;
145
146	if (a->nb_formats && b->nb_formats) {
147	MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
148	} else if (a->nb_formats) {
149	MERGE_REF(a, b, formats, AVFilterFormats, fail);
150	ret = a;
151	} else {
152	MERGE_REF(b, a, formats, AVFilterFormats, fail);
153	ret = b;
154	}
155
156	return ret;
157	fail:
158	if (ret) {
159	av_freep(&ret->refs);
160	av_freep(&ret->formats);
161	}
162	av_freep(&ret);
163	return NULL;
164	}
165
166	AVFilterChannelLayouts ff_merge_channel_layouts(AVFilterChannelLayouts a,
167	AVFilterChannelLayouts *b)
168	{
169	AVFilterChannelLayouts *ret = NULL;
170	unsigned a_all = a->all_layouts + a->all_counts;
171	unsigned b_all = b->all_layouts + b->all_counts;
172	int ret_max, ret_nb = 0, i, j, round;
173
174	if (a == b) return a;
175
176	/* Put the most generic set in a, to avoid doing everything twice */
177	if (a_all < b_all) {
178	FFSWAP(AVFilterChannelLayouts *, a, b);
179	FFSWAP(unsigned, a_all, b_all);
180	}
181	if (a_all) {
182	if (a_all == 1 && !b_all) {
183	/* keep only known layouts in b; works also for b_all = 1 */
184	for (i = j = 0; i < b->nb_channel_layouts; i++)
185	if (KNOWN(b->channel_layouts[i]))
186	b->channel_layouts[j++] = b->channel_layouts[i];
187	/* Not optimal: the unknown layouts of b may become known after
188	another merge. */
189	if (!j)
190	return NULL;
191	b->nb_channel_layouts = j;
192	}
193	MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
194	return b;
195	}
196
197	ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
198	if (!(ret = av_mallocz(sizeof(*ret))) \|\|
199	!(ret->channel_layouts = av_malloc_array(ret_max,
200	sizeof(*ret->channel_layouts))))
201	goto fail;
202
203	/* a[known] intersect b[known] */
204	for (i = 0; i < a->nb_channel_layouts; i++) {
205	if (!KNOWN(a->channel_layouts[i]))
206	continue;
207	for (j = 0; j < b->nb_channel_layouts; j++) {
208	if (a->channel_layouts[i] == b->channel_layouts[j]) {
209	ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
210	a->channel_layouts[i] = b->channel_layouts[j] = 0;
211	}
212	}
213	}
214	/* 1st round: a[known] intersect b[generic]
215	2nd round: a[generic] intersect b[known] */
216	for (round = 0; round < 2; round++) {
217	for (i = 0; i < a->nb_channel_layouts; i++) {
218	uint64_t fmt = a->channel_layouts[i], bfmt;
219	if (!fmt \|\| !KNOWN(fmt))
220	continue;
221	bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));
222	for (j = 0; j < b->nb_channel_layouts; j++)
223	if (b->channel_layouts[j] == bfmt)
224	ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
225	}
226	/* 1st round: swap to prepare 2nd round; 2nd round: put it back */
227	FFSWAP(AVFilterChannelLayouts *, a, b);
228	}
229	/* a[generic] intersect b[generic] */
230	for (i = 0; i < a->nb_channel_layouts; i++) {
231	if (KNOWN(a->channel_layouts[i]))
232	continue;
233	for (j = 0; j < b->nb_channel_layouts; j++)
234	if (a->channel_layouts[i] == b->channel_layouts[j])
235	ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
236	}
237
238	ret->nb_channel_layouts = ret_nb;
239	if (!ret->nb_channel_layouts)
240	goto fail;
241	MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
242	MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);
243	return ret;
244
245	fail:
246	if (ret) {
247	av_freep(&ret->refs);
248	av_freep(&ret->channel_layouts);
249	}
250	av_freep(&ret);
251	return NULL;
252	}
253
254	int ff_fmt_is_in(int fmt, const int *fmts)
255	{
256	const int *p;
257
258	for (p = fmts; *p != -1; p++) {
259	if (fmt == *p)
260	return 1;
261	}
262	return 0;
263	}
264
265	#define COPY_INT_LIST(list_copy, list, type) { \
266	int count = 0; \
267	if (list) \
268	for (count = 0; list[count] != -1; count++) \
269	; \
270	list_copy = av_calloc(count+1, sizeof(type)); \
271	if (list_copy) { \
272	memcpy(list_copy, list, sizeof(type) * count); \
273	list_copy[count] = -1; \
274	} \
275	}
276
277	#define MAKE_FORMAT_LIST(type, field, count_field) \
278	type *formats; \
279	int count = 0; \
280	if (fmts) \
281	for (count = 0; fmts[count] != -1; count++) \
282	; \
283	formats = av_mallocz(sizeof(*formats)); \
284	if (!formats) return NULL; \
285	formats->count_field = count; \
286	if (count) { \
287	formats->field = av_malloc_array(count, sizeof(*formats->field)); \
288	if (!formats->field) { \
289	av_free(formats); \
290	return NULL; \
291	} \
292	}
293
294	AVFilterFormats ff_make_format_list(const int fmts)
295	{
296	MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
297	while (count--)
298	formats->formats[count] = fmts[count];
299
300	return formats;
301	}
302
303	AVFilterChannelLayouts avfilter_make_format64_list(const int64_t fmts)
304	{
305	MAKE_FORMAT_LIST(AVFilterChannelLayouts,
306	channel_layouts, nb_channel_layouts);
307	if (count)
308	memcpy(formats->channel_layouts, fmts,
309	sizeof(formats->channel_layouts) count);
310
311	return formats;
312	}
313
314	#define ADD_FORMAT(f, fmt, type, list, nb) \
315	do { \
316	type *fmts; \
f6fa7814	317	void oldf = f; \
2ba45a60 DM	318	\
	319	if (!(f) && !(f = av_mallocz(sizeof(**f)))) \
	320	return AVERROR(ENOMEM); \
	321	\
	322	fmts = av_realloc((*f)->list, \
	323	sizeof((f)->list) * ((*f)->nb + 1));\
f6fa7814 DM	324	if (!fmts) { \
	325	if (!oldf) \
	326	av_freep(f); \
2ba45a60	327	return AVERROR(ENOMEM); \
f6fa7814	328	} \
2ba45a60 DM	329	\
	330	(*f)->list = fmts; \
	331	(f)->list[(f)->nb++] = fmt; \
	332	} while (0)
	333
	334	int ff_add_format(AVFilterFormats **avff, int64_t fmt)
	335	{
	336	ADD_FORMAT(avff, fmt, int, formats, nb_formats);
	337	return 0;
	338	}
	339
	340	int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
	341	{
	342	av_assert1(!(l && (l)->all_layouts));
	343	ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
	344	return 0;
	345	}
	346
	347	AVFilterFormats *ff_all_formats(enum AVMediaType type)
	348	{
	349	AVFilterFormats *ret = NULL;
	350
	351	if (type == AVMEDIA_TYPE_VIDEO) {
	352	const AVPixFmtDescriptor *desc = NULL;
	353	while ((desc = av_pix_fmt_desc_next(desc))) {
	354	if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
	355	ff_add_format(&ret, av_pix_fmt_desc_get_id(desc));
	356	}
	357	} else if (type == AVMEDIA_TYPE_AUDIO) {
	358	enum AVSampleFormat fmt = 0;
	359	while (av_get_sample_fmt_name(fmt)) {
	360	ff_add_format(&ret, fmt);
	361	fmt++;
	362	}
	363	}
	364
	365	return ret;
	366	}
	367
	368	const int64_t avfilter_all_channel_layouts[] = {
	369	#include "all_channel_layouts.inc"
	370	-1
	371	};
	372
	373	// AVFilterFormats *avfilter_make_all_channel_layouts(void)
	374	// {
	375	// return avfilter_make_format64_list(avfilter_all_channel_layouts);
	376	// }
	377
	378	AVFilterFormats *ff_planar_sample_fmts(void)
	379	{
	380	AVFilterFormats *ret = NULL;
	381	int fmt;
	382
	383	for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
	384	if (av_sample_fmt_is_planar(fmt))
	385	ff_add_format(&ret, fmt);
	386
	387	return ret;
	388	}
	389
	390	AVFilterFormats *ff_all_samplerates(void)
	391	{
	392	AVFilterFormats ret = av_mallocz(sizeof(ret));
393	return ret;
394	}
395
396	AVFilterChannelLayouts *ff_all_channel_layouts(void)
397	{
398	AVFilterChannelLayouts ret = av_mallocz(sizeof(ret));
399	if (!ret)
400	return NULL;
401	ret->all_layouts = 1;
402	return ret;
403	}
404
405	AVFilterChannelLayouts *ff_all_channel_counts(void)
406	{
407	AVFilterChannelLayouts ret = av_mallocz(sizeof(ret));
408	if (!ret)
409	return NULL;
410	ret->all_layouts = ret->all_counts = 1;
411	return ret;
412	}
413
414	#define FORMATS_REF(f, ref) \
415	do { \
416	*ref = f; \
417	f->refs = av_realloc(f->refs, sizeof(f->refs) ++f->refcount); \
418	f->refs[f->refcount-1] = ref; \
419	} while (0)
420
421	void ff_channel_layouts_ref(AVFilterChannelLayouts f, AVFilterChannelLayouts *ref)
422	{
423	FORMATS_REF(f, ref);
424	}
425
426	void ff_formats_ref(AVFilterFormats f, AVFilterFormats *ref)
427	{
428	FORMATS_REF(f, ref);
429	}
430
431	#define FIND_REF_INDEX(ref, idx) \
432	do { \
433	int i; \
434	for (i = 0; i < (*ref)->refcount; i ++) \
435	if((*ref)->refs[i] == ref) { \
436	idx = i; \
437	break; \
438	} \
439	} while (0)
440
441	#define FORMATS_UNREF(ref, list) \
442	do { \
443	int idx = -1; \
444	\
445	if (!*ref) \
446	return; \
447	\
448	FIND_REF_INDEX(ref, idx); \
449	\
450	if (idx >= 0) \
451	memmove((ref)->refs + idx, (ref)->refs + idx + 1, \
452	sizeof((ref)->refs) * ((*ref)->refcount - idx - 1)); \
453	\
454	if(!--(*ref)->refcount) { \
455	av_free((*ref)->list); \
456	av_free((*ref)->refs); \
457	av_free(*ref); \
458	} \
459	*ref = NULL; \
460	} while (0)
461
462	void ff_formats_unref(AVFilterFormats **ref)
463	{
464	FORMATS_UNREF(ref, formats);
465	}
466
467	void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
468	{
469	FORMATS_UNREF(ref, channel_layouts);
470	}
471
472	#define FORMATS_CHANGEREF(oldref, newref) \
473	do { \
474	int idx = -1; \
475	\
476	FIND_REF_INDEX(oldref, idx); \
477	\
478	if (idx >= 0) { \
479	(*oldref)->refs[idx] = newref; \
480	newref = oldref; \
481	*oldref = NULL; \
482	} \
483	} while (0)
484
485	void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
486	AVFilterChannelLayouts **newref)
487	{
488	FORMATS_CHANGEREF(oldref, newref);
489	}
490
491	void ff_formats_changeref(AVFilterFormats oldref, AVFilterFormats newref)
492	{
493	FORMATS_CHANGEREF(oldref, newref);
494	}
495
496	#define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
f6fa7814	497	if (fmts) { \
2ba45a60 DM	498	int count = 0, i; \
	499	\
	500	for (i = 0; i < ctx->nb_inputs; i++) { \
	501	if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
	502	ref(fmts, &ctx->inputs[i]->out_fmts); \
	503	count++; \
	504	} \
	505	} \
	506	for (i = 0; i < ctx->nb_outputs; i++) { \
	507	if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
	508	ref(fmts, &ctx->outputs[i]->in_fmts); \
	509	count++; \
	510	} \
	511	} \
	512	\
	513	if (!count) { \
	514	av_freep(&fmts->list); \
	515	av_freep(&fmts->refs); \
	516	av_freep(&fmts); \
	517	} \
	518	}
	519
	520	void ff_set_common_channel_layouts(AVFilterContext *ctx,
	521	AVFilterChannelLayouts *layouts)
	522	{
	523	SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
	524	ff_channel_layouts_ref, channel_layouts);
	525	}
	526
	527	void ff_set_common_samplerates(AVFilterContext *ctx,
	528	AVFilterFormats *samplerates)
	529	{
	530	SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
	531	ff_formats_ref, formats);
	532	}
	533
	534	/**
	535	* A helper for query_formats() which sets all links to the same list of
	536	* formats. If there are no links hooked to this filter, the list of formats is
	537	* freed.
	538	*/
	539	void ff_set_common_formats(AVFilterContext ctx, AVFilterFormats formats)
	540	{
	541	SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
	542	ff_formats_ref, formats);
	543	}
	544
	545	static int default_query_formats_common(AVFilterContext *ctx,
	546	AVFilterChannelLayouts *(layouts)(void))
	547	{
	548	enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
	549	ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
	550	AVMEDIA_TYPE_VIDEO;
	551
	552	ff_set_common_formats(ctx, ff_all_formats(type));
	553	if (type == AVMEDIA_TYPE_AUDIO) {
	554	ff_set_common_channel_layouts(ctx, layouts());
	555	ff_set_common_samplerates(ctx, ff_all_samplerates());
	556	}
	557
	558	return 0;
	559	}
	560
	561	int ff_default_query_formats(AVFilterContext *ctx)
562	{
563	return default_query_formats_common(ctx, ff_all_channel_layouts);
564	}
565
566	int ff_query_formats_all(AVFilterContext *ctx)
567	{
568	return default_query_formats_common(ctx, ff_all_channel_counts);
569	}
570
571	/* internal functions for parsing audio format arguments */
572
573	int ff_parse_pixel_format(enum AVPixelFormat ret, const char arg, void *log_ctx)
574	{
575	char *tail;
576	int pix_fmt = av_get_pix_fmt(arg);
577	if (pix_fmt == AV_PIX_FMT_NONE) {
578	pix_fmt = strtol(arg, &tail, 0);
579	if (*tail \|\| !av_pix_fmt_desc_get(pix_fmt)) {
580	av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
581	return AVERROR(EINVAL);
582	}
583	}
584	*ret = pix_fmt;
585	return 0;
586	}
587
588	int ff_parse_sample_format(int ret, const char arg, void *log_ctx)
589	{
590	char *tail;
591	int sfmt = av_get_sample_fmt(arg);
592	if (sfmt == AV_SAMPLE_FMT_NONE) {
593	sfmt = strtol(arg, &tail, 0);
594	if (*tail \|\| av_get_bytes_per_sample(sfmt)<=0) {
595	av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
596	return AVERROR(EINVAL);
597	}
598	}
599	*ret = sfmt;
600	return 0;
601	}
602
603	int ff_parse_time_base(AVRational ret, const char arg, void *log_ctx)
604	{
605	AVRational r;
606	if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 \|\|r.num<=0 \|\|r.den<=0) {
607	av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
608	return AVERROR(EINVAL);
609	}
610	*ret = r;
611	return 0;
612	}
613
614	int ff_parse_sample_rate(int ret, const char arg, void *log_ctx)
615	{
616	char *tail;
617	double srate = av_strtod(arg, &tail);
618	if (*tail \|\| srate < 1 \|\| (int)srate != srate \|\| srate > INT_MAX) {
619	av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
620	return AVERROR(EINVAL);
621	}
622	*ret = srate;
623	return 0;
624	}
625
626	int ff_parse_channel_layout(int64_t ret, int nret, const char *arg,
627	void *log_ctx)
628	{
629	char *tail;
630	int64_t chlayout, count;
631
632	if (nret) {
633	count = strtol(arg, &tail, 10);
634	if (*tail == 'c' && !tail[1] && count > 0 && count < 63) {
635	*nret = count;
636	*ret = 0;
637	return 0;
638	}
639	}
640	chlayout = av_get_channel_layout(arg);
641	if (chlayout == 0) {
642	chlayout = strtol(arg, &tail, 10);
643	if (*tail \|\| chlayout == 0) {
644	av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
645	return AVERROR(EINVAL);
646	}
647	}
648	*ret = chlayout;
649	if (nret)
650	*nret = av_get_channel_layout_nb_channels(chlayout);
651	return 0;
652	}
653
654	#ifdef TEST
655
656	#undef printf
657
658	int main(void)
659	{
660	const int64_t *cl;
661	char buf[512];
662
663	for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
664	av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
665	printf("%s\n", buf);
666	}
667
668	return 0;
669	}
670
671	#endif
672