git.sesse.net Git - ffmpeg/blob - libavcodec/filter_units_bsf.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include <stdlib.h>
  20
  21 #include "libavutil/common.h"
  22 #include "libavutil/opt.h"
  23
  24 #include "bsf.h"
  25 #include "cbs.h"
  26
  27
  28 typedef struct FilterUnitsContext {
  29     const AVClass *class;
  30
  31     CodedBitstreamContext *cbc;
  32     CodedBitstreamFragment fragment;
  33
  34     const char *pass_types;
  35     const char *remove_types;
  36
  37     enum {
  38         NOOP,
  39         PASS,
  40         REMOVE,
  41     } mode;
  42     CodedBitstreamUnitType *type_list;
  43     int nb_types;
  44 } FilterUnitsContext;
  45
  46
  47 static int filter_units_make_type_list(const char *list_string,
  48                                        CodedBitstreamUnitType **type_list,
  49                                        int *nb_types)
  50 {
  51     CodedBitstreamUnitType *list = NULL;
  52     int pass, count;
  53
  54     for (pass = 1; pass <= 2; pass++) {
  55         long value, range_start, range_end;
  56         const char *str;
  57         char *value_end;
  58
  59         count = 0;
  60         for (str = list_string; *str;) {
  61             value = strtol(str, &value_end, 0);
  62             if (str == value_end)
  63                 goto invalid;
  64             str = (const char *)value_end;
  65             if (*str == '-') {
  66                 ++str;
  67                 range_start = value;
  68                 range_end   = strtol(str, &value_end, 0);
  69                 if (str == value_end)
  70                     goto invalid;
  71
  72                 for (value = range_start; value < range_end; value++) {
  73                     if (pass == 2)
  74                         list[count] = value;
  75                     ++count;
  76                 }
  77             } else {
  78                 if (pass == 2)
  79                     list[count] = value;
  80                 ++count;
  81             }
  82             if (*str == '|')
  83                 ++str;
  84         }
  85         if (pass == 1) {
  86             list = av_malloc_array(count, sizeof(*list));
  87             if (!list)
  88                 return AVERROR(ENOMEM);
  89         }
  90     }
  91
  92     *type_list = list;
  93     *nb_types  = count;
  94     return 0;
  95
  96 invalid:
  97     av_freep(&list);
  98     return AVERROR(EINVAL);
  99 }
 100
 101 static int filter_units_filter(AVBSFContext *bsf, AVPacket *out)
 102 {
 103     FilterUnitsContext      *ctx = bsf->priv_data;
 104     CodedBitstreamFragment *frag = &ctx->fragment;
 105     AVPacket *in = NULL;
 106     int err, i, j;
 107
 108     while (1) {
 109         err = ff_bsf_get_packet(bsf, &in);
 110         if (err < 0)
 111             return err;
 112
 113         if (ctx->mode == NOOP) {
 114             av_packet_move_ref(out, in);
 115             av_packet_free(&in);
 116             return 0;
 117         }
 118
 119         err = ff_cbs_read_packet(ctx->cbc, frag, in);
 120         if (err < 0) {
 121             av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
 122             goto fail;
 123         }
 124
 125         for (i = 0; i < frag->nb_units; i++) {
 126             for (j = 0; j < ctx->nb_types; j++) {
 127                 if (frag->units[i].type == ctx->type_list[j])
 128                     break;
 129             }
 130             if (ctx->mode == REMOVE ? j <  ctx->nb_types
 131                                     : j >= ctx->nb_types) {
 132                 ff_cbs_delete_unit(ctx->cbc, frag, i);
 133                 --i;
 134             }
 135         }
 136
 137         if (frag->nb_units > 0)
 138             break;
 139
 140         // Don't return packets with nothing in them.
 141         av_packet_free(&in);
 142         ff_cbs_fragment_uninit(ctx->cbc, frag);
 143     }
 144
 145     err = ff_cbs_write_packet(ctx->cbc, out, frag);
 146     if (err < 0) {
 147         av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
 148         goto fail;
 149     }
 150
 151     err = av_packet_copy_props(out, in);
 152     if (err < 0)
 153         goto fail;
 154
 155 fail:
 156     ff_cbs_fragment_uninit(ctx->cbc, frag);
 157     av_packet_free(&in);
 158
 159     return err;
 160 }
 161
 162 static int filter_units_init(AVBSFContext *bsf)
 163 {
 164     FilterUnitsContext *ctx = bsf->priv_data;
 165     int err;
 166
 167     if (ctx->pass_types && ctx->remove_types) {
 168         av_log(bsf, AV_LOG_ERROR, "Exactly one of pass_types or "
 169                "remove_types is required.\n");
 170         return AVERROR(EINVAL);
 171     }
 172
 173     if (ctx->pass_types) {
 174         ctx->mode = PASS;
 175         err = filter_units_make_type_list(ctx->pass_types,
 176                                           &ctx->type_list, &ctx->nb_types);
 177         if (err < 0) {
 178             av_log(bsf, AV_LOG_ERROR, "Failed to parse pass_types.\n");
 179             return err;
 180         }
 181     } else if (ctx->remove_types) {
 182         ctx->mode = REMOVE;
 183         err = filter_units_make_type_list(ctx->remove_types,
 184                                           &ctx->type_list, &ctx->nb_types);
 185         if (err < 0) {
 186             av_log(bsf, AV_LOG_ERROR, "Failed to parse remove_types.\n");
 187             return err;
 188         }
 189     } else {
 190         return 0;
 191     }
 192
 193     err = ff_cbs_init(&ctx->cbc, bsf->par_in->codec_id, bsf);
 194     if (err < 0)
 195         return err;
 196
 197     // Don't actually decompose anything, we only want the unit data.
 198     ctx->cbc->decompose_unit_types    = ctx->type_list;
 199     ctx->cbc->nb_decompose_unit_types = 0;
 200
 201     if (bsf->par_in->extradata) {
 202         CodedBitstreamFragment ps;
 203
 204         err = ff_cbs_read_extradata(ctx->cbc, &ps, bsf->par_in);
 205         if (err < 0) {
 206             av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
 207         } else {
 208             err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, &ps);
 209             if (err < 0)
 210                 av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
 211         }
 212
 213         ff_cbs_fragment_uninit(ctx->cbc, &ps);
 214     }
 215
 216     return err;
 217 }
 218
 219 static void filter_units_close(AVBSFContext *bsf)
 220 {
 221     FilterUnitsContext *ctx = bsf->priv_data;
 222
 223     av_freep(&ctx->type_list);
 224
 225     ff_cbs_close(&ctx->cbc);
 226 }
 227
 228 #define OFFSET(x) offsetof(FilterUnitsContext, x)
 229 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
 230 static const AVOption filter_units_options[] = {
 231     { "pass_types",   "List of unit types to pass through the filter.",
 232         OFFSET(pass_types),   AV_OPT_TYPE_STRING,
 233         { .str = NULL }, .flags = FLAGS },
 234     { "remove_types", "List of unit types to remove in the filter.",
 235         OFFSET(remove_types), AV_OPT_TYPE_STRING,
 236         { .str = NULL }, .flags = FLAGS },
 237
 238     { NULL }
 239 };
 240
 241 static const AVClass filter_units_class = {
 242     .class_name = "filter_units",
 243     .item_name  = av_default_item_name,
 244     .option     = filter_units_options,
 245     .version    = LIBAVUTIL_VERSION_INT,
 246 };
 247
 248 const AVBitStreamFilter ff_filter_units_bsf = {
 249     .name           = "filter_units",
 250     .priv_data_size = sizeof(FilterUnitsContext),
 251     .priv_class     = &filter_units_class,
 252     .init           = &filter_units_init,
 253     .close          = &filter_units_close,
 254     .filter         = &filter_units_filter,
 255     .codec_ids      = ff_cbs_all_codec_ids,
 256 };