git.sesse.net Git - ffmpeg/blob - libavfilter/vf_qp.c

   1 /*
   2  * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
   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 #include <math.h>
  22 #include "libavutil/eval.h"
  23 #include "libavutil/imgutils.h"
  24 #include "libavutil/pixdesc.h"
  25 #include "libavutil/opt.h"
  26 #include "avfilter.h"
  27 #include "formats.h"
  28 #include "internal.h"
  29 #include "video.h"
  30
  31 typedef struct QPContext {
  32     const AVClass *class;
  33     char *qp_expr_str;
  34     int8_t lut[257];
  35     int h, qstride;
  36 } QPContext;
  37
  38 #define OFFSET(x) offsetof(QPContext, x)
  39 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
  40
  41 static const AVOption qp_options[] = {
  42     { "qp", "set qp expression", OFFSET(qp_expr_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
  43     { NULL }
  44 };
  45
  46 AVFILTER_DEFINE_CLASS(qp);
  47
  48 static int config_input(AVFilterLink *inlink)
  49 {
  50     AVFilterContext *ctx = inlink->dst;
  51     QPContext *s = ctx->priv;
  52     int i;
  53
  54     if (!s->qp_expr_str)
  55         return 0;
  56
  57     s->h       = (inlink->h + 15) >> 4;
  58     s->qstride = (inlink->w + 15) >> 4;
  59     for (i = -129; i < 128; i++) {
  60         double var_values[] = { i != -129, i, 0 };
  61         static const char *var_names[] = { "known", "qp", NULL };
  62         double temp_val;
  63         int ret;
  64
  65         ret = av_expr_parse_and_eval(&temp_val, s->qp_expr_str,
  66                                      var_names, var_values,
  67                                      NULL, NULL, NULL, NULL, 0, 0, ctx);
  68         if (ret < 0)
  69             return ret;
  70
  71         s->lut[i + 129] = lrintf(temp_val);
  72     }
  73
  74     return 0;
  75 }
  76
  77 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
  78 {
  79     AVFilterContext *ctx = inlink->dst;
  80     AVFilterLink *outlink = ctx->outputs[0];
  81     QPContext *s = ctx->priv;
  82     AVBufferRef *out_qp_table_buf;
  83     AVFrame *out;
  84     const int8_t *in_qp_table;
  85     int type, stride, ret;
  86
  87     if (!s->qp_expr_str || ctx->is_disabled)
  88         return ff_filter_frame(outlink, in);
  89
  90     out_qp_table_buf = av_buffer_alloc(s->h * s->qstride);
  91     if (!out_qp_table_buf) {
  92         ret = AVERROR(ENOMEM);
  93         goto fail;
  94     }
  95
  96     out = av_frame_clone(in);
  97     if (!out) {
  98         av_buffer_unref(&out_qp_table_buf);
  99         ret = AVERROR(ENOMEM);
 100         goto fail;
 101     }
 102
 103     in_qp_table = av_frame_get_qp_table(in, &stride, &type);
 104     av_frame_set_qp_table(out, out_qp_table_buf, s->qstride, type);
 105
 106     if (in_qp_table) {
 107         int y, x;
 108
 109         for (y = 0; y < s->h; y++)
 110             for (x = 0; x < s->qstride; x++)
 111                 out_qp_table_buf->data[x + s->qstride * y] = s->lut[129 +
 112                     ((int8_t)in_qp_table[x + stride * y])];
 113     } else {
 114         int y, x, qp = s->lut[0];
 115
 116         for (y = 0; y < s->h; y++)
 117             for (x = 0; x < s->qstride; x++)
 118                 out_qp_table_buf->data[x + s->qstride * y] = qp;
 119     }
 120
 121     ret = ff_filter_frame(outlink, out);
 122 fail:
 123     av_frame_free(&in);
 124     return ret;
 125 }
 126
 127 static const AVFilterPad qp_inputs[] = {
 128     {
 129         .name         = "default",
 130         .type         = AVMEDIA_TYPE_VIDEO,
 131         .filter_frame = filter_frame,
 132         .config_props = config_input,
 133     },
 134     { NULL }
 135 };
 136
 137 static const AVFilterPad qp_outputs[] = {
 138     {
 139         .name = "default",
 140         .type = AVMEDIA_TYPE_VIDEO,
 141     },
 142     { NULL }
 143 };
 144
 145 AVFilter ff_vf_qp = {
 146     .name          = "qp",
 147     .description   = NULL_IF_CONFIG_SMALL("Change video quantization parameters."),
 148     .priv_size     = sizeof(QPContext),
 149     .inputs        = qp_inputs,
 150     .outputs       = qp_outputs,
 151     .priv_class    = &qp_class,
 152     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
 153 };