Merge remote-tracking branch 'qatar/master'

[ffmpeg] / libavfilter / formats.c

diff --git a/libavfilter/formats.c b/libavfilter/formats.c
index 101ef09e5f308d3016853c063898c994a36b6b8b..214718b77911ddf08895e83c2495d88f66907d6a 100644 (file)
--- a/libavfilter/formats.c
+++ b/libavfilter/formats.c
@@ -20,7 +20,9 @@
  */
 
 #include "libavutil/pixdesc.h"
+#include "libavutil/audioconvert.h"
 #include "avfilter.h"
+#include "internal.h"
 
 /**
  * Add all refs from a to ret and destroy a.
@@ -29,7 +31,7 @@ static void merge_ref(AVFilterFormats *ret, AVFilterFormats *a)
 {
     int i;
 
-    for(i = 0; i < a->refcount; i ++) {
+    for (i = 0; i < a->refcount; i++) {
         ret->refs[ret->refcount] = a->refs[i];
         *ret->refs[ret->refcount++] = ret;
     }
@@ -44,19 +46,21 @@ AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *b)
     AVFilterFormats *ret;
     unsigned i, j, k = 0;
 
+    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])
+    for (i = 0; i < a->format_count; i++)
+        for (j = 0; j < b->format_count; j++)
+            if (a->formats[i] == b->formats[j])
                 ret->formats[k++] = a->formats[i];
 
     ret->format_count = k;
     /* check that there was at least one common format */
-    if(!ret->format_count) {
+    if (!ret->format_count) {
         av_free(ret->formats);
         av_free(ret);
         return NULL;
@@ -70,31 +74,61 @@ AVFilterFormats *avfilter_merge_formats(AVFilterFormats *a, AVFilterFormats *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 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)
 {
-    AVFilterFormats *formats;
-    int count;
+    MAKE_FORMAT_LIST();
+    while (count--)
+        formats->formats[count] = fmts[count];
 
-    for (count = 0; fmts[count] != -1; count++)
-        ;
+    return formats;
+}
 
-    formats               = av_mallocz(sizeof(AVFilterFormats));
-    formats->formats      = av_malloc(sizeof(*formats->formats) * count);
-    formats->format_count = count;
-    memcpy(formats->formats, fmts, sizeof(*formats->formats) * count);
+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, int fmt)
+int avfilter_add_format(AVFilterFormats **avff, int64_t fmt)
 {
-    int *fmts;
+    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));
+                      sizeof(*(*avff)->formats) * ((*avff)->format_count+1));
     if (!fmts)
         return AVERROR(ENOMEM);
 
@@ -118,6 +152,38 @@ AVFilterFormats *avfilter_all_formats(enum AVMediaType type)
     return ret;
 }
 
+AVFilterFormats *avfilter_all_channel_layouts(void)
+{
+    static int64_t chlayouts[] = {
+        AV_CH_LAYOUT_MONO,
+        AV_CH_LAYOUT_STEREO,
+        AV_CH_LAYOUT_4POINT0,
+        AV_CH_LAYOUT_QUAD,
+        AV_CH_LAYOUT_5POINT0,
+        AV_CH_LAYOUT_5POINT0_BACK,
+        AV_CH_LAYOUT_5POINT1,
+        AV_CH_LAYOUT_5POINT1_BACK,
+        AV_CH_LAYOUT_5POINT1|AV_CH_LAYOUT_STEREO_DOWNMIX,
+        AV_CH_LAYOUT_7POINT1,
+        AV_CH_LAYOUT_7POINT1_WIDE,
+        AV_CH_LAYOUT_7POINT1|AV_CH_LAYOUT_STEREO_DOWNMIX,
+        -1,
+    };
+
+    return avfilter_make_format64_list(chlayouts);
+}
+
+AVFilterFormats *avfilter_all_packing_formats(void)
+{
+    static int packing[] = {
+        AVFILTER_PACKED,
+        AVFILTER_PLANAR,
+        -1,
+    };
+
+    return avfilter_make_format_list(packing);
+}
+
 void avfilter_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
 {
     *ref = f;
@@ -128,8 +194,8 @@ void avfilter_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
 static int find_ref_index(AVFilterFormats **ref)
 {
     int i;
-    for(i = 0; i < (*ref)->refcount; i ++)
-        if((*ref)->refs[i] == ref)
+    for (i = 0; i < (*ref)->refcount; i++)
+        if ((*ref)->refs[i] == ref)
             return i;
     return -1;
 }
@@ -143,11 +209,11 @@ void avfilter_formats_unref(AVFilterFormats **ref)
 
     idx = find_ref_index(ref);
 
-    if(idx >= 0)
+    if (idx >= 0)
         memmove((*ref)->refs + idx, (*ref)->refs + idx+1,
             sizeof(AVFilterFormats**) * ((*ref)->refcount-idx-1));
 
-    if(!--(*ref)->refcount) {
+    if (!--(*ref)->refcount) {
         av_free((*ref)->formats);
         av_free((*ref)->refs);
         av_free(*ref);
@@ -160,7 +226,7 @@ void avfilter_formats_changeref(AVFilterFormats **oldref,
 {
     int idx = find_ref_index(oldref);
 
-    if(idx >= 0) {
+    if (idx >= 0) {
         (*oldref)->refs[idx] = newref;
         *newref = *oldref;
         *oldref = NULL;