FFmpeg
vf_dnn_classify.c
Go to the documentation of this file.
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 /**
20  * @file
21  * implementing an classification filter using deep learning networks.
22  */
23 
24 #include "libavformat/avio.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/avassert.h"
28 #include "libavutil/imgutils.h"
29 #include "filters.h"
30 #include "dnn_filter_common.h"
31 #include "formats.h"
32 #include "internal.h"
33 #include "libavutil/time.h"
34 #include "libavutil/avstring.h"
36 
37 typedef struct DnnClassifyContext {
38  const AVClass *class;
40  float confidence;
42  char *target;
43  char **labels;
46 
47 #define OFFSET(x) offsetof(DnnClassifyContext, dnnctx.x)
48 #define OFFSET2(x) offsetof(DnnClassifyContext, x)
49 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
50 static const AVOption dnn_classify_options[] = {
51  { "dnn_backend", "DNN backend", OFFSET(backend_type), AV_OPT_TYPE_INT, { .i64 = 2 }, INT_MIN, INT_MAX, FLAGS, "backend" },
52 #if (CONFIG_LIBOPENVINO == 1)
53  { "openvino", "openvino backend flag", 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, 0, 0, FLAGS, "backend" },
54 #endif
56  { "confidence", "threshold of confidence", OFFSET2(confidence), AV_OPT_TYPE_FLOAT, { .dbl = 0.5 }, 0, 1, FLAGS},
57  { "labels", "path to labels file", OFFSET2(labels_filename), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
58  { "target", "which one to be classified", OFFSET2(target), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, FLAGS },
59  { NULL }
60 };
61 
62 AVFILTER_DEFINE_CLASS(dnn_classify);
63 
65 {
67  float conf_threshold = ctx->confidence;
69  AVDetectionBBox *bbox;
70  float *classifications;
71  uint32_t label_id;
72  float confidence;
73  AVFrameSideData *sd;
74 
75  if (output->channels <= 0) {
76  return -1;
77  }
78 
80  if (!sd) {
81  av_log(filter_ctx, AV_LOG_ERROR, "Cannot get side data in dnn_classify_post_proc\n");
82  return -1;
83  }
85 
86  if (bbox_index == 0) {
87  av_strlcat(header->source, ", ", sizeof(header->source));
88  av_strlcat(header->source, ctx->dnnctx.model_filename, sizeof(header->source));
89  }
90 
91  classifications = output->data;
92  label_id = 0;
93  confidence= classifications[0];
94  for (int i = 1; i < output->channels; i++) {
95  if (classifications[i] > confidence) {
96  label_id = i;
97  confidence= classifications[i];
98  }
99  }
100 
101  if (confidence < conf_threshold) {
102  return 0;
103  }
104 
105  bbox = av_get_detection_bbox(header, bbox_index);
106  bbox->classify_confidences[bbox->classify_count] = av_make_q((int)(confidence * 10000), 10000);
107 
108  if (ctx->labels && label_id < ctx->label_count) {
109  av_strlcpy(bbox->classify_labels[bbox->classify_count], ctx->labels[label_id], sizeof(bbox->classify_labels[bbox->classify_count]));
110  } else {
111  snprintf(bbox->classify_labels[bbox->classify_count], sizeof(bbox->classify_labels[bbox->classify_count]), "%d", label_id);
112  }
113 
114  bbox->classify_count++;
115 
116  return 0;
117 }
118 
120 {
121  for (int i = 0; i < ctx->label_count; i++) {
122  av_freep(&ctx->labels[i]);
123  }
124  ctx->label_count = 0;
125  av_freep(&ctx->labels);
126 }
127 
129 {
130  int line_len;
131  FILE *file;
132  DnnClassifyContext *ctx = context->priv;
133 
134  file = av_fopen_utf8(ctx->labels_filename, "r");
135  if (!file){
136  av_log(context, AV_LOG_ERROR, "failed to open file %s\n", ctx->labels_filename);
137  return AVERROR(EINVAL);
138  }
139 
140  while (!feof(file)) {
141  char *label;
142  char buf[256];
143  if (!fgets(buf, 256, file)) {
144  break;
145  }
146 
147  line_len = strlen(buf);
148  while (line_len) {
149  int i = line_len - 1;
150  if (buf[i] == '\n' || buf[i] == '\r' || buf[i] == ' ') {
151  buf[i] = '\0';
152  line_len--;
153  } else {
154  break;
155  }
156  }
157 
158  if (line_len == 0) // empty line
159  continue;
160 
161  if (line_len >= AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE) {
162  av_log(context, AV_LOG_ERROR, "label %s too long\n", buf);
163  fclose(file);
164  return AVERROR(EINVAL);
165  }
166 
167  label = av_strdup(buf);
168  if (!label) {
169  av_log(context, AV_LOG_ERROR, "failed to allocate memory for label %s\n", buf);
170  fclose(file);
171  return AVERROR(ENOMEM);
172  }
173 
174  if (av_dynarray_add_nofree(&ctx->labels, &ctx->label_count, label) < 0) {
175  av_log(context, AV_LOG_ERROR, "failed to do av_dynarray_add\n");
176  fclose(file);
177  av_freep(&label);
178  return AVERROR(ENOMEM);
179  }
180  }
181 
182  fclose(file);
183  return 0;
184 }
185 
187 {
188  DnnClassifyContext *ctx = context->priv;
190  if (ret < 0)
191  return ret;
193 
194  if (ctx->labels_filename) {
196  }
197  return 0;
198 }
199 
201 {
202  static const enum AVPixelFormat pix_fmts[] = {
209  };
211  return ff_set_common_formats(context, fmts_list);
212 }
213 
214 static int dnn_classify_flush_frame(AVFilterLink *outlink, int64_t pts, int64_t *out_pts)
215 {
216  DnnClassifyContext *ctx = outlink->src->priv;
217  int ret;
218  DNNAsyncStatusType async_state;
219 
220  ret = ff_dnn_flush(&ctx->dnnctx);
221  if (ret != DNN_SUCCESS) {
222  return -1;
223  }
224 
225  do {
226  AVFrame *in_frame = NULL;
227  AVFrame *out_frame = NULL;
228  async_state = ff_dnn_get_async_result(&ctx->dnnctx, &in_frame, &out_frame);
229  if (out_frame) {
230  av_assert0(in_frame == out_frame);
231  ret = ff_filter_frame(outlink, out_frame);
232  if (ret < 0)
233  return ret;
234  if (out_pts)
235  *out_pts = out_frame->pts + pts;
236  }
237  av_usleep(5000);
238  } while (async_state >= DAST_NOT_READY);
239 
240  return 0;
241 }
242 
244 {
245  AVFilterLink *inlink = filter_ctx->inputs[0];
246  AVFilterLink *outlink = filter_ctx->outputs[0];
248  AVFrame *in = NULL;
249  int64_t pts;
250  int ret, status;
251  int got_frame = 0;
252  int async_state;
253 
255 
256  do {
257  // drain all input frames
259  if (ret < 0)
260  return ret;
261  if (ret > 0) {
262  if (ff_dnn_execute_model_classification(&ctx->dnnctx, in, in, ctx->target) != DNN_SUCCESS) {
263  return AVERROR(EIO);
264  }
265  }
266  } while (ret > 0);
267 
268  // drain all processed frames
269  do {
270  AVFrame *in_frame = NULL;
271  AVFrame *out_frame = NULL;
272  async_state = ff_dnn_get_async_result(&ctx->dnnctx, &in_frame, &out_frame);
273  if (out_frame) {
274  av_assert0(in_frame == out_frame);
275  ret = ff_filter_frame(outlink, out_frame);
276  if (ret < 0)
277  return ret;
278  got_frame = 1;
279  }
280  } while (async_state == DAST_SUCCESS);
281 
282  // if frame got, schedule to next filter
283  if (got_frame)
284  return 0;
285 
287  if (status == AVERROR_EOF) {
288  int64_t out_pts = pts;
289  ret = dnn_classify_flush_frame(outlink, pts, &out_pts);
290  ff_outlink_set_status(outlink, status, out_pts);
291  return ret;
292  }
293  }
294 
296 
297  return 0;
298 }
299 
301 {
302  DnnClassifyContext *ctx = context->priv;
303  ff_dnn_uninit(&ctx->dnnctx);
305 }
306 
308  {
309  .name = "default",
310  .type = AVMEDIA_TYPE_VIDEO,
311  },
312  { NULL }
313 };
314 
316  {
317  .name = "default",
318  .type = AVMEDIA_TYPE_VIDEO,
319  },
320  { NULL }
321 };
322 
324  .name = "dnn_classify",
325  .description = NULL_IF_CONFIG_SMALL("Apply DNN classify filter to the input."),
326  .priv_size = sizeof(DnnClassifyContext),
332  .priv_class = &dnn_classify_class,
334 };
dnn_classify_flush_frame
static int dnn_classify_flush_frame(AVFilterLink *outlink, int64_t pts, int64_t *out_pts)
Definition: vf_dnn_classify.c:214
free_classify_labels
static void free_classify_labels(DnnClassifyContext *ctx)
Definition: vf_dnn_classify.c:119
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
filter_ctx
static FilteringContext * filter_ctx
Definition: transcoding.c:48
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:286
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:616
dnn_classify_query_formats
static int dnn_classify_query_formats(AVFilterContext *context)
Definition: vf_dnn_classify.c:200
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:396
AVOption
AVOption.
Definition: opt.h:248
DnnClassifyContext::confidence
float confidence
Definition: vf_dnn_classify.c:40
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(dnn_classify)
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:149
dnn_filter_common.h
FF_FILTER_FORWARD_STATUS_BACK
#define FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink)
Forward the status on an output link to an input link.
Definition: filters.h:199
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:65
formats.h
ff_inlink_consume_frame
int ff_inlink_consume_frame(AVFilterLink *link, AVFrame **rframe)
Take a frame from the link's FIFO and update the link's stats.
Definition: avfilter.c:1376
AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE
#define AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE
Definition: detection_bbox.h:36
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:348
dnn_classify_post_proc
static int dnn_classify_post_proc(AVFrame *frame, DNNData *output, uint32_t bbox_index, AVFilterContext *filter_ctx)
Definition: vf_dnn_classify.c:64
DnnContext
Definition: dnn_filter_common.h:29
DNN_SUCCESS
@ DNN_SUCCESS
Definition: dnn_interface.h:33
ff_dnn_execute_model_classification
DNNReturnType ff_dnn_execute_model_classification(DnnContext *ctx, AVFrame *in_frame, AVFrame *out_frame, char *target)
Definition: dnn_filter_common.c:156
pts
static int64_t pts
Definition: transcode_aac.c:652
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
av_get_detection_bbox
static av_always_inline AVDetectionBBox * av_get_detection_bbox(const AVDetectionBBoxHeader *header, unsigned int idx)
Definition: detection_bbox.h:84
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
dnn_classify_options
static const AVOption dnn_classify_options[]
Definition: vf_dnn_classify.c:50
av_cold
#define av_cold
Definition: attributes.h:90
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:580
av_fopen_utf8
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:158
ff_outlink_set_status
static void ff_outlink_set_status(AVFilterLink *link, int status, int64_t pts)
Set the status field of a link from the source filter.
Definition: filters.h:189
AVDetectionBBox::classify_confidences
AVRational classify_confidences[AV_NUM_DETECTION_BBOX_CLASSIFY]
Definition: detection_bbox.h:53
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
DNNData
Definition: dnn_interface.h:59
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
filters.h
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
DnnClassifyContext
Definition: vf_dnn_classify.c:37
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
OFFSET2
#define OFFSET2(x)
Definition: vf_dnn_classify.c:48
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:421
if
if(ret)
Definition: filter_design.txt:179
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
AVDetectionBBox::classify_labels
char classify_labels[AV_NUM_DETECTION_BBOX_CLASSIFY][AV_DETECTION_BBOX_LABEL_NAME_MAX_SIZE]
Definition: detection_bbox.h:52
AVDetectionBBoxHeader
Definition: detection_bbox.h:56
activate
filter_frame For filters that do not use the activate() callback
dnn_classify_init
static av_cold int dnn_classify_init(AVFilterContext *context)
Definition: vf_dnn_classify.c:186
dnn_classify_inputs
static const AVFilterPad dnn_classify_inputs[]
Definition: vf_dnn_classify.c:307
time.h
DnnClassifyContext::target
char * target
Definition: vf_dnn_classify.c:42
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
ff_inlink_acknowledge_status
int ff_inlink_acknowledge_status(AVFilterLink *link, int *rstatus, int64_t *rpts)
Test and acknowledge the change of status on the link.
Definition: avfilter.c:1331
DNN_COMMON_OPTIONS
#define DNN_COMMON_OPTIONS
Definition: dnn_filter_common.h:43
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
DAST_SUCCESS
@ DAST_SUCCESS
Definition: dnn_interface.h:49
dnn_classify_outputs
static const AVFilterPad dnn_classify_outputs[]
Definition: vf_dnn_classify.c:315
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
avio.h
AVFrameSideData::data
uint8_t * data
Definition: frame.h:211
DnnClassifyContext::label_count
int label_count
Definition: vf_dnn_classify.c:44
header
static const uint8_t header[24]
Definition: sdr2.c:67
AVDetectionBBox::classify_count
uint32_t classify_count
Definition: detection_bbox.h:51
FF_FILTER_FORWARD_WANTED
FF_FILTER_FORWARD_WANTED(outlink, inlink)
DnnClassifyContext::labels
char ** labels
Definition: vf_dnn_classify.c:43
internal.h
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:228
ff_vf_dnn_classify
const AVFilter ff_vf_dnn_classify
Definition: vf_dnn_classify.c:323
i
int i
Definition: input.c:407
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
dnn_classify_uninit
static av_cold void dnn_classify_uninit(AVFilterContext *context)
Definition: vf_dnn_classify.c:300
AVFilter
Filter definition.
Definition: avfilter.h:145
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
av_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:93
OFFSET
#define OFFSET(x)
Definition: vf_dnn_classify.c:47
av_dynarray_add_nofree
int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
Add an element to a dynamic array.
Definition: mem.c:303
DFT_ANALYTICS_CLASSIFY
@ DFT_ANALYTICS_CLASSIFY
Definition: dnn_interface.h:56
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:260
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:209
FLAGS
#define FLAGS
Definition: vf_dnn_classify.c:49
ff_dnn_init
int ff_dnn_init(DnnContext *ctx, DNNFunctionType func_type, AVFilterContext *filter_ctx)
Definition: dnn_filter_common.c:54
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
dnn_classify_activate
static int dnn_classify_activate(AVFilterContext *filter_ctx)
Definition: vf_dnn_classify.c:243
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: aeval.c:244
ff_dnn_flush
DNNReturnType ff_dnn_flush(DnnContext *ctx)
Definition: dnn_filter_common.c:176
imgutils.h
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_dnn_uninit
void ff_dnn_uninit(DnnContext *ctx)
Definition: dnn_filter_common.c:181
AVDetectionBBox
Definition: detection_bbox.h:26
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:279
read_classify_label_file
static int read_classify_label_file(AVFilterContext *context)
Definition: vf_dnn_classify.c:128
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
DAST_NOT_READY
@ DAST_NOT_READY
Definition: dnn_interface.h:48
DNNAsyncStatusType
DNNAsyncStatusType
Definition: dnn_interface.h:45
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
snprintf
#define snprintf
Definition: snprintf.h:34
detection_bbox.h
ff_dnn_get_async_result
DNNAsyncStatusType ff_dnn_get_async_result(DnnContext *ctx, AVFrame **in_frame, AVFrame **out_frame)
Definition: dnn_filter_common.c:171
ff_dnn_set_classify_post_proc
int ff_dnn_set_classify_post_proc(DnnContext *ctx, ClassifyPostProc post_proc)
Definition: dnn_filter_common.c:115
AV_FRAME_DATA_DETECTION_BBOXES
@ AV_FRAME_DATA_DETECTION_BBOXES
Bounding boxes for object detection and classification, as described by AVDetectionBBoxHeader.
Definition: frame.h:189
DnnClassifyContext::labels_filename
char * labels_filename
Definition: vf_dnn_classify.c:41
DnnClassifyContext::dnnctx
DnnContext dnnctx
Definition: vf_dnn_classify.c:39