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

 #include "libavutil/pixdesc.h"

 #include "libavutil/audioconvert.h"

 #include "avfilter.h"

 #include "internal.h"

 /**
  * Add all refs from a to ret and destroy a.
  */

 static void merge_ref(AVFilterFormats *ret, AVFilterFormats *a)
 {
     int i;

     for (i = 0; i < a->refcount; i++) {

         ret->refs[ret->refcount] = a->refs[i];
         *ret->refs[ret->refcount++] = ret;
     }

 
     av_free(a->refs);
     av_free(a->formats);
     av_free(a);

 }
 

 AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b)
 {
     AVFilterFormats *ret;
     unsigned i, j, k = 0;
 

     if (a == b) return a;
 

     if (a == b)
         return a;
 

     ret = av_mallocz(sizeof(AVFilterFormats));
 
     /* merge list of formats */

     ret->formats = av_malloc(sizeof(*ret->formats) * FFMIN(a->format_count,
                                                            b->format_count));

     for (i = 0; i < a->format_count; i++)
         for (j = 0; j < b->format_count; j++)

             if (a->formats[i] == b->formats[j]){

                 if(k >= FFMIN(a->format_count, b->format_count)){
                     av_log(0, AV_LOG_ERROR, "Duplicate formats in avfilter_merge_formats() detected\n");
                     av_free(ret->formats);
                     av_free(ret);
                     return NULL;
                 }

                 ret->formats[k++] = a->formats[i];

             }

     ret->format_count = k;

     /* check that there was at least one common format */

     if (!ret->format_count) {

         av_free(ret->formats);
         av_free(ret);
         return NULL;
     }
 
     ret->refs = av_malloc(sizeof(AVFilterFormats**)*(a->refcount+b->refcount));

 
     merge_ref(ret, a);
     merge_ref(ret, b);

 
     return ret;
 }
 

 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;                                          \
     }                                                                   \
 }
 
 int *ff_copy_int_list(const int * const list)
 {
     int *ret = NULL;
     COPY_INT_LIST(ret, list, int);
     return ret;
 }
 
 int64_t *ff_copy_int64_list(const int64_t * const list)
 {
     int64_t *ret = NULL;
     COPY_INT_LIST(ret, list, int64_t);
     return ret;
 }
 

 #define MAKE_FORMAT_LIST()                                              \
     AVFilterFormats *formats;                                           \
     int count = 0;                                                      \
     if (fmts)                                                           \
         for (count = 0; fmts[count] != -1; count++)                     \
             ;                                                           \
     formats = av_mallocz(sizeof(AVFilterFormats));                      \
     if (!formats) return NULL;                                          \
     formats->format_count = count;                                      \
     if (count) {                                                        \

         formats->formats = av_malloc(sizeof(*formats->formats)*count);  \

         if (!formats->formats) {                                        \
             av_free(formats);                                           \
             return NULL;                                                \
         }                                                               \
     }
 

 AVFilterFormats *avfilter_make_format_list(const int *fmts)

 {

     MAKE_FORMAT_LIST();
     while (count--)
         formats->formats[count] = fmts[count];

     return formats;
 }

 AVFilterFormats *avfilter_make_format64_list(const int64_t *fmts)
 {
     MAKE_FORMAT_LIST();
     if (count)

         memcpy(formats->formats, fmts, sizeof(*formats->formats) * count);

 
     return formats;
 }
 

 int avfilter_add_format(AVFilterFormats **avff, int64_t fmt)

 {

     int64_t *fmts;

     if (!(*avff) && !(*avff = av_mallocz(sizeof(AVFilterFormats))))
         return AVERROR(ENOMEM);
 

     fmts = av_realloc((*avff)->formats,

                       sizeof(*(*avff)->formats) * ((*avff)->format_count+1));

     if (!fmts)

         return AVERROR(ENOMEM);
 

     (*avff)->formats = fmts;
     (*avff)->formats[(*avff)->format_count++] = fmt;

     return 0;
 }
 

 #if FF_API_OLD_ALL_FORMATS_API

 AVFilterFormats *avfilter_all_formats(enum AVMediaType type)

 {

     return avfilter_make_all_formats(type);
 }
 #endif
 
 AVFilterFormats *avfilter_make_all_formats(enum AVMediaType type)
 {

     AVFilterFormats *ret = NULL;

     int fmt;

     int num_formats = type == AVMEDIA_TYPE_VIDEO ? PIX_FMT_NB    :

                       type == AVMEDIA_TYPE_AUDIO ? AV_SAMPLE_FMT_NB : 0;

     for (fmt = 0; fmt < num_formats; fmt++)
         if ((type != AVMEDIA_TYPE_VIDEO) ||
             (type == AVMEDIA_TYPE_VIDEO && !(av_pix_fmt_descriptors[fmt].flags & PIX_FMT_HWACCEL)))
             avfilter_add_format(&ret, fmt);

 
     return ret;

 }
 

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

 AVFilterFormats *avfilter_make_all_channel_layouts(void)

 {

     return avfilter_make_format64_list(avfilter_all_channel_layouts);

 }
 

 AVFilterFormats *avfilter_make_all_packing_formats(void)

 {

     static const int packing[] = {

         AVFILTER_PACKED,
         AVFILTER_PLANAR,
         -1,
     };
 
     return avfilter_make_format_list(packing);
 }
 

 void avfilter_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
 {
     *ref = f;
     f->refs = av_realloc(f->refs, sizeof(AVFilterFormats**) * ++f->refcount);
     f->refs[f->refcount-1] = ref;
 }
 

 static int find_ref_index(AVFilterFormats **ref)

 {
     int i;

     for (i = 0; i < (*ref)->refcount; i++)
         if ((*ref)->refs[i] == ref)

             return i;
     return -1;
 }
 

 void avfilter_formats_unref(AVFilterFormats **ref)
 {

     int idx;
 

     if (!*ref)
         return;
 

     idx = find_ref_index(ref);

     if (idx >= 0)

         memmove((*ref)->refs + idx, (*ref)->refs + idx+1,
             sizeof(AVFilterFormats**) * ((*ref)->refcount-idx-1));
 

     if (!--(*ref)->refcount) {

         av_free((*ref)->formats);
         av_free((*ref)->refs);
         av_free(*ref);
     }
     *ref = NULL;
 }
 

 void avfilter_formats_changeref(AVFilterFormats **oldref,
                                 AVFilterFormats **newref)
 {

     int idx = find_ref_index(oldref);

     if (idx >= 0) {

         (*oldref)->refs[idx] = newref;
         *newref = *oldref;
         *oldref = NULL;
     }
 }
 

 /* internal functions for parsing audio format arguments */
 

 int ff_parse_pixel_format(enum PixelFormat *ret, const char *arg, void *log_ctx)
 {
     char *tail;
     int pix_fmt = av_get_pix_fmt(arg);
     if (pix_fmt == PIX_FMT_NONE) {
         pix_fmt = strtol(arg, &tail, 0);
         if (*tail || (unsigned)pix_fmt >= PIX_FMT_NB) {
             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 || (unsigned)sfmt >= AV_SAMPLE_FMT_NB) {
             av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
             return AVERROR(EINVAL);
         }
     }
     *ret = sfmt;
     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, const char *arg, void *log_ctx)
 {
     char *tail;
     int64_t 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;
     return 0;
 }
 
 int ff_parse_packing_format(int *ret, const char *arg, void *log_ctx)
 {
     char *tail;
     int planar = strtol(arg, &tail, 10);
     if (*tail) {

         planar = !strcmp(arg, "packed") ? 0:
                  !strcmp(arg, "planar") ? 1: -1;
     }
 
     if (planar != 0 && planar != 1) {

         av_log(log_ctx, AV_LOG_ERROR, "Invalid packing format '%s'\n", arg);
         return AVERROR(EINVAL);
     }
     *ret = planar;
     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