Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2007 Bobby Bingham
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. /**
  22.  * @file
  23.  * format and noformat video filters
  24.  */
  25.  
  26. #include <string.h>
  27.  
  28. #include "libavutil/internal.h"
  29. #include "libavutil/mem.h"
  30. #include "libavutil/pixdesc.h"
  31. #include "libavutil/opt.h"
  32.  
  33. #include "avfilter.h"
  34. #include "formats.h"
  35. #include "internal.h"
  36. #include "video.h"
  37.  
  38. typedef struct FormatContext {
  39.     const AVClass *class;
  40.     char *pix_fmts;
  41.  
  42.     /**
  43.      * pix_fmts parsed into AVPixelFormats and terminated with
  44.      * AV_PIX_FMT_NONE
  45.      */
  46.     enum AVPixelFormat *formats;
  47. } FormatContext;
  48.  
  49. static av_cold void uninit(AVFilterContext *ctx)
  50. {
  51.     FormatContext *s = ctx->priv;
  52.     av_freep(&s->formats);
  53. }
  54.  
  55. static av_cold int init(AVFilterContext *ctx)
  56. {
  57.     FormatContext *s = ctx->priv;
  58.     char *cur, *sep;
  59.     int nb_formats = 1;
  60.     int i;
  61.     int ret;
  62.  
  63.     if (!s->pix_fmts) {
  64.         av_log(ctx, AV_LOG_ERROR, "Empty output format string.\n");
  65.         return AVERROR(EINVAL);
  66.     }
  67.  
  68.     /* count the formats */
  69.     cur = s->pix_fmts;
  70.     while ((cur = strchr(cur, '|'))) {
  71.         nb_formats++;
  72.         if (*cur)
  73.             cur++;
  74.     }
  75.  
  76.     s->formats = av_malloc_array(nb_formats + 1, sizeof(*s->formats));
  77.     if (!s->formats)
  78.         return AVERROR(ENOMEM);
  79.  
  80.     /* parse the list of formats */
  81.     cur = s->pix_fmts;
  82.     for (i = 0; i < nb_formats; i++) {
  83.         sep = strchr(cur, '|');
  84.         if (sep)
  85.             *sep++ = 0;
  86.  
  87.         if ((ret = ff_parse_pixel_format(&s->formats[i], cur, ctx)) < 0)
  88.             return ret;
  89.  
  90.         cur = sep;
  91.     }
  92.     s->formats[nb_formats] = AV_PIX_FMT_NONE;
  93.  
  94.     if (!strcmp(ctx->filter->name, "noformat")) {
  95.         const AVPixFmtDescriptor *desc = NULL;
  96.         enum AVPixelFormat *formats_allowed;
  97.         int nb_formats_lavu = 0, nb_formats_allowed = 0;
  98.  
  99.         /* count the formats known to lavu */
  100.         while ((desc = av_pix_fmt_desc_next(desc)))
  101.             nb_formats_lavu++;
  102.  
  103.         formats_allowed = av_malloc_array(nb_formats_lavu + 1, sizeof(*formats_allowed));
  104.         if (!formats_allowed)
  105.             return AVERROR(ENOMEM);
  106.  
  107.         /* for each format known to lavu, check if it's in the list of
  108.          * forbidden formats */
  109.         while ((desc = av_pix_fmt_desc_next(desc))) {
  110.             enum AVPixelFormat pix_fmt = av_pix_fmt_desc_get_id(desc);
  111.  
  112.             for (i = 0; i < nb_formats; i++) {
  113.                 if (s->formats[i] == pix_fmt)
  114.                     break;
  115.             }
  116.             if (i < nb_formats)
  117.                 continue;
  118.  
  119.             formats_allowed[nb_formats_allowed++] = pix_fmt;
  120.         }
  121.         formats_allowed[nb_formats_allowed] = AV_PIX_FMT_NONE;
  122.         av_freep(&s->formats);
  123.         s->formats = formats_allowed;
  124.     }
  125.  
  126.     return 0;
  127. }
  128.  
  129. static int query_formats(AVFilterContext *ctx)
  130. {
  131.     FormatContext *s = ctx->priv;
  132.     AVFilterFormats *formats = ff_make_format_list(s->formats);
  133.  
  134.     if (!formats)
  135.         return AVERROR(ENOMEM);
  136.  
  137.     return ff_set_common_formats(ctx, formats);
  138. }
  139.  
  140.  
  141. #define OFFSET(x) offsetof(FormatContext, x)
  142. static const AVOption options[] = {
  143.     { "pix_fmts", "A '|'-separated list of pixel formats", OFFSET(pix_fmts), AV_OPT_TYPE_STRING, .flags = AV_OPT_FLAG_VIDEO_PARAM },
  144.     { NULL }
  145. };
  146.  
  147. #if CONFIG_FORMAT_FILTER
  148.  
  149. #define format_options options
  150. AVFILTER_DEFINE_CLASS(format);
  151.  
  152. static const AVFilterPad avfilter_vf_format_inputs[] = {
  153.     {
  154.         .name             = "default",
  155.         .type             = AVMEDIA_TYPE_VIDEO,
  156.         .get_video_buffer = ff_null_get_video_buffer,
  157.     },
  158.     { NULL }
  159. };
  160.  
  161. static const AVFilterPad avfilter_vf_format_outputs[] = {
  162.     {
  163.         .name = "default",
  164.         .type = AVMEDIA_TYPE_VIDEO
  165.     },
  166.     { NULL }
  167. };
  168.  
  169. AVFilter ff_vf_format = {
  170.     .name          = "format",
  171.     .description   = NULL_IF_CONFIG_SMALL("Convert the input video to one of the specified pixel formats."),
  172.  
  173.     .init          = init,
  174.     .uninit        = uninit,
  175.  
  176.     .query_formats = query_formats,
  177.  
  178.     .priv_size     = sizeof(FormatContext),
  179.     .priv_class    = &format_class,
  180.  
  181.     .inputs        = avfilter_vf_format_inputs,
  182.     .outputs       = avfilter_vf_format_outputs,
  183. };
  184. #endif /* CONFIG_FORMAT_FILTER */
  185.  
  186. #if CONFIG_NOFORMAT_FILTER
  187.  
  188. #define noformat_options options
  189. AVFILTER_DEFINE_CLASS(noformat);
  190.  
  191. static const AVFilterPad avfilter_vf_noformat_inputs[] = {
  192.     {
  193.         .name             = "default",
  194.         .type             = AVMEDIA_TYPE_VIDEO,
  195.         .get_video_buffer = ff_null_get_video_buffer,
  196.     },
  197.     { NULL }
  198. };
  199.  
  200. static const AVFilterPad avfilter_vf_noformat_outputs[] = {
  201.     {
  202.         .name = "default",
  203.         .type = AVMEDIA_TYPE_VIDEO
  204.     },
  205.     { NULL }
  206. };
  207.  
  208. AVFilter ff_vf_noformat = {
  209.     .name          = "noformat",
  210.     .description   = NULL_IF_CONFIG_SMALL("Force libavfilter not to use any of the specified pixel formats for the input to the next filter."),
  211.  
  212.     .init          = init,
  213.     .uninit        = uninit,
  214.  
  215.     .query_formats = query_formats,
  216.  
  217.     .priv_size     = sizeof(FormatContext),
  218.     .priv_class    = &noformat_class,
  219.  
  220.     .inputs        = avfilter_vf_noformat_inputs,
  221.     .outputs       = avfilter_vf_noformat_outputs,
  222. };
  223. #endif /* CONFIG_NOFORMAT_FILTER */
  224.