[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;                                             \
                                                            \
    if (!(*f) && !(*f = av_mallocz(sizeof(**f))))           \
        return AVERROR(ENOMEM);                             \
                                                            \
    fmts = av_realloc((*f)->list,                           \
                      sizeof(*(*f)->list) * ((*f)->nb + 1));\
    if (!fmts)                                              \
        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) \
{                                                                   \
    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; \
317	\
318	if (!(f) && !(f = av_mallocz(sizeof(**f)))) \
319	return AVERROR(ENOMEM); \
320	\
321	fmts = av_realloc((*f)->list, \
322	sizeof((f)->list) * ((*f)->nb + 1));\
323	if (!fmts) \
324	return AVERROR(ENOMEM); \
325	\
326	(*f)->list = fmts; \
327	(f)->list[(f)->nb++] = fmt; \
328	} while (0)
329
330	int ff_add_format(AVFilterFormats **avff, int64_t fmt)
331	{
332	ADD_FORMAT(avff, fmt, int, formats, nb_formats);
333	return 0;
334	}
335
336	int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
337	{
338	av_assert1(!(l && (l)->all_layouts));
339	ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
340	return 0;
341	}
342
343	AVFilterFormats *ff_all_formats(enum AVMediaType type)
344	{
345	AVFilterFormats *ret = NULL;
346
347	if (type == AVMEDIA_TYPE_VIDEO) {
348	const AVPixFmtDescriptor *desc = NULL;
349	while ((desc = av_pix_fmt_desc_next(desc))) {
350	if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
351	ff_add_format(&ret, av_pix_fmt_desc_get_id(desc));
352	}
353	} else if (type == AVMEDIA_TYPE_AUDIO) {
354	enum AVSampleFormat fmt = 0;
355	while (av_get_sample_fmt_name(fmt)) {
356	ff_add_format(&ret, fmt);
357	fmt++;
358	}
359	}
360
361	return ret;
362	}
363
364	const int64_t avfilter_all_channel_layouts[] = {
365	#include "all_channel_layouts.inc"
366	-1
367	};
368
369	// AVFilterFormats *avfilter_make_all_channel_layouts(void)
370	// {
371	// return avfilter_make_format64_list(avfilter_all_channel_layouts);
372	// }
373
374	AVFilterFormats *ff_planar_sample_fmts(void)
375	{
376	AVFilterFormats *ret = NULL;
377	int fmt;
378
379	for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
380	if (av_sample_fmt_is_planar(fmt))
381	ff_add_format(&ret, fmt);
382
383	return ret;
384	}
385
386	AVFilterFormats *ff_all_samplerates(void)
387	{
388	AVFilterFormats ret = av_mallocz(sizeof(ret));
389	return ret;
390	}
391
392	AVFilterChannelLayouts *ff_all_channel_layouts(void)
393	{
394	AVFilterChannelLayouts ret = av_mallocz(sizeof(ret));
395	if (!ret)
396	return NULL;
397	ret->all_layouts = 1;
398	return ret;
399	}
400
401	AVFilterChannelLayouts *ff_all_channel_counts(void)
402	{
403	AVFilterChannelLayouts ret = av_mallocz(sizeof(ret));
404	if (!ret)
405	return NULL;
406	ret->all_layouts = ret->all_counts = 1;
407	return ret;
408	}
409
410	#define FORMATS_REF(f, ref) \
411	do { \
412	*ref = f; \
413	f->refs = av_realloc(f->refs, sizeof(f->refs) ++f->refcount); \
414	f->refs[f->refcount-1] = ref; \
415	} while (0)
416
417	void ff_channel_layouts_ref(AVFilterChannelLayouts f, AVFilterChannelLayouts *ref)
418	{
419	FORMATS_REF(f, ref);
420	}
421
422	void ff_formats_ref(AVFilterFormats f, AVFilterFormats *ref)
423	{
424	FORMATS_REF(f, ref);
425	}
426
427	#define FIND_REF_INDEX(ref, idx) \
428	do { \
429	int i; \
430	for (i = 0; i < (*ref)->refcount; i ++) \
431	if((*ref)->refs[i] == ref) { \
432	idx = i; \
433	break; \
434	} \
435	} while (0)
436
437	#define FORMATS_UNREF(ref, list) \
438	do { \
439	int idx = -1; \
440	\
441	if (!*ref) \
442	return; \
443	\
444	FIND_REF_INDEX(ref, idx); \
445	\
446	if (idx >= 0) \
447	memmove((ref)->refs + idx, (ref)->refs + idx + 1, \
448	sizeof((ref)->refs) * ((*ref)->refcount - idx - 1)); \
449	\
450	if(!--(*ref)->refcount) { \
451	av_free((*ref)->list); \
452	av_free((*ref)->refs); \
453	av_free(*ref); \
454	} \
455	*ref = NULL; \
456	} while (0)
457
458	void ff_formats_unref(AVFilterFormats **ref)
459	{
460	FORMATS_UNREF(ref, formats);
461	}
462
463	void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
464	{
465	FORMATS_UNREF(ref, channel_layouts);
466	}
467
468	#define FORMATS_CHANGEREF(oldref, newref) \
469	do { \
470	int idx = -1; \
471	\
472	FIND_REF_INDEX(oldref, idx); \
473	\
474	if (idx >= 0) { \
475	(*oldref)->refs[idx] = newref; \
476	newref = oldref; \
477	*oldref = NULL; \
478	} \
479	} while (0)
480
481	void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
482	AVFilterChannelLayouts **newref)
483	{
484	FORMATS_CHANGEREF(oldref, newref);
485	}
486
487	void ff_formats_changeref(AVFilterFormats oldref, AVFilterFormats newref)
488	{
489	FORMATS_CHANGEREF(oldref, newref);
490	}
491
492	#define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
493	{ \
494	int count = 0, i; \
495	\
496	for (i = 0; i < ctx->nb_inputs; i++) { \
497	if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
498	ref(fmts, &ctx->inputs[i]->out_fmts); \
499	count++; \
500	} \
501	} \
502	for (i = 0; i < ctx->nb_outputs; i++) { \
503	if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
504	ref(fmts, &ctx->outputs[i]->in_fmts); \
505	count++; \
506	} \
507	} \
508	\
509	if (!count) { \
510	av_freep(&fmts->list); \
511	av_freep(&fmts->refs); \
512	av_freep(&fmts); \
513	} \
514	}
515
516	void ff_set_common_channel_layouts(AVFilterContext *ctx,
517	AVFilterChannelLayouts *layouts)
518	{
519	SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
520	ff_channel_layouts_ref, channel_layouts);
521	}
522
523	void ff_set_common_samplerates(AVFilterContext *ctx,
524	AVFilterFormats *samplerates)
525	{
526	SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
527	ff_formats_ref, formats);
528	}
529
530	/**
531	* A helper for query_formats() which sets all links to the same list of
532	* formats. If there are no links hooked to this filter, the list of formats is
533	* freed.
534	*/
535	void ff_set_common_formats(AVFilterContext ctx, AVFilterFormats formats)
536	{
537	SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
538	ff_formats_ref, formats);
539	}
540
541	static int default_query_formats_common(AVFilterContext *ctx,
542	AVFilterChannelLayouts *(layouts)(void))
543	{
544	enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
545	ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
546	AVMEDIA_TYPE_VIDEO;
547
548	ff_set_common_formats(ctx, ff_all_formats(type));
549	if (type == AVMEDIA_TYPE_AUDIO) {
550	ff_set_common_channel_layouts(ctx, layouts());
551	ff_set_common_samplerates(ctx, ff_all_samplerates());
552	}
553
554	return 0;
555	}
556
557	int ff_default_query_formats(AVFilterContext *ctx)
558	{
559	return default_query_formats_common(ctx, ff_all_channel_layouts);
560	}
561
562	int ff_query_formats_all(AVFilterContext *ctx)
563	{
564	return default_query_formats_common(ctx, ff_all_channel_counts);
565	}
566
567	/* internal functions for parsing audio format arguments */
568
569	int ff_parse_pixel_format(enum AVPixelFormat ret, const char arg, void *log_ctx)
570	{
571	char *tail;
572	int pix_fmt = av_get_pix_fmt(arg);
573	if (pix_fmt == AV_PIX_FMT_NONE) {
574	pix_fmt = strtol(arg, &tail, 0);
575	if (*tail \|\| !av_pix_fmt_desc_get(pix_fmt)) {
576	av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
577	return AVERROR(EINVAL);
578	}
579	}
580	*ret = pix_fmt;
581	return 0;
582	}
583
584	int ff_parse_sample_format(int ret, const char arg, void *log_ctx)
585	{
586	char *tail;
587	int sfmt = av_get_sample_fmt(arg);
588	if (sfmt == AV_SAMPLE_FMT_NONE) {
589	sfmt = strtol(arg, &tail, 0);
590	if (*tail \|\| av_get_bytes_per_sample(sfmt)<=0) {
591	av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
592	return AVERROR(EINVAL);
593	}
594	}
595	*ret = sfmt;
596	return 0;
597	}
598
599	int ff_parse_time_base(AVRational ret, const char arg, void *log_ctx)
600	{
601	AVRational r;
602	if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 \|\|r.num<=0 \|\|r.den<=0) {
603	av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
604	return AVERROR(EINVAL);
605	}
606	*ret = r;
607	return 0;
608	}
609
610	int ff_parse_sample_rate(int ret, const char arg, void *log_ctx)
611	{
612	char *tail;
613	double srate = av_strtod(arg, &tail);
614	if (*tail \|\| srate < 1 \|\| (int)srate != srate \|\| srate > INT_MAX) {
615	av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
616	return AVERROR(EINVAL);
617	}
618	*ret = srate;
619	return 0;
620	}
621
622	int ff_parse_channel_layout(int64_t ret, int nret, const char *arg,
623	void *log_ctx)
624	{
625	char *tail;
626	int64_t chlayout, count;
627
628	if (nret) {
629	count = strtol(arg, &tail, 10);
630	if (*tail == 'c' && !tail[1] && count > 0 && count < 63) {
631	*nret = count;
632	*ret = 0;
633	return 0;
634	}
635	}
636	chlayout = av_get_channel_layout(arg);
637	if (chlayout == 0) {
638	chlayout = strtol(arg, &tail, 10);
639	if (*tail \|\| chlayout == 0) {
640	av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
641	return AVERROR(EINVAL);
642	}
643	}
644	*ret = chlayout;
645	if (nret)
646	*nret = av_get_channel_layout_nb_channels(chlayout);
647	return 0;
648	}
649
650	#ifdef TEST
651
652	#undef printf
653
654	int main(void)
655	{
656	const int64_t *cl;
657	char buf[512];
658
659	for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
660	av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
661	printf("%s\n", buf);
662	}
663
664	return 0;
665	}
666
667	#endif
668