avfilter/af_afir: do not over allocate fft buffer
[ffmpeg.git] / libavfilter / vf_thumbnail_cuda.c
1 /*
2 * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 * DEALINGS IN THE SOFTWARE.
21 */
22
23 #include <cuda.h>
24
25 #include "libavutil/hwcontext.h"
26 #include "libavutil/hwcontext_cuda.h"
27 #include "libavutil/cuda_check.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30
31 #include "avfilter.h"
32 #include "internal.h"
33
34 #define CHECK_CU(x) FF_CUDA_CHECK(ctx, x)
35
36 #define HIST_SIZE (3*256)
37 #define DIV_UP(a, b) ( ((a) + (b) - 1) / (b) )
38 #define BLOCKX 32
39 #define BLOCKY 16
40
41 static const enum AVPixelFormat supported_formats[] = {
42     AV_PIX_FMT_NV12,
43     AV_PIX_FMT_YUV420P,
44     AV_PIX_FMT_YUV444P,
45     AV_PIX_FMT_P010,
46     AV_PIX_FMT_P016,
47     AV_PIX_FMT_YUV444P16,
48 };
49
50 struct thumb_frame {
51     AVFrame *buf;               ///< cached frame
52     int histogram[HIST_SIZE];   ///< RGB color distribution histogram of the frame
53 };
54
55 typedef struct ThumbnailCudaContext {
56     const AVClass *class;
57     int n;                      ///< current frame
58     int n_frames;               ///< number of frames for analysis
59     struct thumb_frame *frames; ///< the n_frames frames
60     AVRational tb;              ///< copy of the input timebase to ease access
61
62     AVBufferRef *hw_frames_ctx;
63
64     CUmodule    cu_module;
65
66     CUfunction  cu_func_uchar;
67     CUfunction  cu_func_uchar2;
68     CUfunction  cu_func_ushort;
69     CUfunction  cu_func_ushort2;
70     CUtexref    cu_tex_uchar;
71     CUtexref    cu_tex_uchar2;
72     CUtexref    cu_tex_ushort;
73     CUtexref    cu_tex_ushort2;
74
75     CUdeviceptr data;
76 } ThumbnailCudaContext;
77
78 #define OFFSET(x) offsetof(ThumbnailCudaContext, x)
79 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
80
81 static const AVOption thumbnail_cuda_options[] = {
82     { "n", "set the frames batch size", OFFSET(n_frames), AV_OPT_TYPE_INT, {.i64=100}, 2, INT_MAX, FLAGS },
83     { NULL }
84 };
85
86 AVFILTER_DEFINE_CLASS(thumbnail_cuda);
87
88 static av_cold int init(AVFilterContext *ctx)
89 {
90     ThumbnailCudaContext *s = ctx->priv;
91
92     s->frames = av_calloc(s->n_frames, sizeof(*s->frames));
93     if (!s->frames) {
94         av_log(ctx, AV_LOG_ERROR,
95                "Allocation failure, try to lower the number of frames\n");
96         return AVERROR(ENOMEM);
97     }
98     av_log(ctx, AV_LOG_VERBOSE, "batch size: %d frames\n", s->n_frames);
99     return 0;
100 }
101
102 /**
103  * @brief        Compute Sum-square deviation to estimate "closeness".
104  * @param hist   color distribution histogram
105  * @param median average color distribution histogram
106  * @return       sum of squared errors
107  */
108 static double frame_sum_square_err(const int *hist, const double *median)
109 {
110     int i;
111     double err, sum_sq_err = 0;
112
113     for (i = 0; i < HIST_SIZE; i++) {
114         err = median[i] - (double)hist[i];
115         sum_sq_err += err*err;
116     }
117     return sum_sq_err;
118 }
119
120 static AVFrame *get_best_frame(AVFilterContext *ctx)
121 {
122     AVFrame *picref;
123     ThumbnailCudaContext *s = ctx->priv;
124     int i, j, best_frame_idx = 0;
125     int nb_frames = s->n;
126     double avg_hist[HIST_SIZE] = {0}, sq_err, min_sq_err = -1;
127
128     // average histogram of the N frames
129     for (j = 0; j < FF_ARRAY_ELEMS(avg_hist); j++) {
130         for (i = 0; i < nb_frames; i++)
131             avg_hist[j] += (double)s->frames[i].histogram[j];
132         avg_hist[j] /= nb_frames;
133     }
134
135     // find the frame closer to the average using the sum of squared errors
136     for (i = 0; i < nb_frames; i++) {
137         sq_err = frame_sum_square_err(s->frames[i].histogram, avg_hist);
138         if (i == 0 || sq_err < min_sq_err)
139             best_frame_idx = i, min_sq_err = sq_err;
140     }
141
142     // free and reset everything (except the best frame buffer)
143     for (i = 0; i < nb_frames; i++) {
144         memset(s->frames[i].histogram, 0, sizeof(s->frames[i].histogram));
145         if (i != best_frame_idx)
146             av_frame_free(&s->frames[i].buf);
147     }
148     s->n = 0;
149
150     // raise the chosen one
151     picref = s->frames[best_frame_idx].buf;
152     av_log(ctx, AV_LOG_INFO, "frame id #%d (pts_time=%f) selected "
153            "from a set of %d images\n", best_frame_idx,
154            picref->pts * av_q2d(s->tb), nb_frames);
155     s->frames[best_frame_idx].buf = NULL;
156
157     return picref;
158 }
159
160 static int thumbnail_kernel(ThumbnailCudaContext *ctx, CUfunction func, CUtexref tex, int channels,
161     int *histogram, uint8_t *src_dptr, int src_width, int src_height, int src_pitch, int pixel_size)
162 {
163     CUdeviceptr src_devptr = (CUdeviceptr)src_dptr;
164     void *args[] = { &histogram, &src_width, &src_height };
165     CUDA_ARRAY_DESCRIPTOR desc;
166
167     desc.Width = src_width;
168     desc.Height = src_height;
169     desc.NumChannels = channels;
170     if (pixel_size == 1) {
171         desc.Format = CU_AD_FORMAT_UNSIGNED_INT8;
172     }
173     else {
174         desc.Format = CU_AD_FORMAT_UNSIGNED_INT16;
175     }
176
177     CHECK_CU(cuTexRefSetAddress2D_v3(tex, &desc, src_devptr, src_pitch));
178     CHECK_CU(cuLaunchKernel(func,
179                             DIV_UP(src_width, BLOCKX), DIV_UP(src_height, BLOCKY), 1,
180                             BLOCKX, BLOCKY, 1, 0, 0, args, NULL));
181
182     return 0;
183 }
184
185 static int thumbnail(AVFilterContext *ctx, int *histogram, AVFrame *in)
186 {
187     AVHWFramesContext *in_frames_ctx = (AVHWFramesContext*)in->hw_frames_ctx->data;
188     ThumbnailCudaContext *s = ctx->priv;
189
190     switch (in_frames_ctx->sw_format) {
191     case AV_PIX_FMT_NV12:
192         thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
193             histogram, in->data[0], in->width, in->height, in->linesize[0], 1);
194         thumbnail_kernel(s, s->cu_func_uchar2, s->cu_tex_uchar2, 2,
195             histogram + 256, in->data[1], in->width / 2, in->height / 2, in->linesize[1], 1);
196         break;
197     case AV_PIX_FMT_YUV420P:
198         thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
199             histogram, in->data[0], in->width, in->height, in->linesize[0], 1);
200         thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
201             histogram + 256, in->data[1], in->width / 2, in->height / 2, in->linesize[1], 1);
202         thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
203             histogram + 512, in->data[2], in->width / 2, in->height / 2, in->linesize[2], 1);
204         break;
205     case AV_PIX_FMT_YUV444P:
206         thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
207             histogram, in->data[0], in->width, in->height, in->linesize[0], 1);
208         thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
209             histogram + 256, in->data[1], in->width, in->height, in->linesize[1], 1);
210         thumbnail_kernel(s, s->cu_func_uchar, s->cu_tex_uchar, 1,
211             histogram + 512, in->data[2], in->width, in->height, in->linesize[2], 1);
212         break;
213     case AV_PIX_FMT_P010LE:
214     case AV_PIX_FMT_P016LE:
215         thumbnail_kernel(s, s->cu_func_ushort, s->cu_tex_ushort, 1,
216             histogram, in->data[0], in->width, in->height, in->linesize[0], 2);
217         thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_ushort2, 2,
218             histogram + 256, in->data[1], in->width / 2, in->height / 2, in->linesize[1], 2);
219         break;
220     case AV_PIX_FMT_YUV444P16:
221         thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_uchar, 1,
222             histogram, in->data[0], in->width, in->height, in->linesize[0], 2);
223         thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_uchar, 1,
224             histogram + 256, in->data[1], in->width, in->height, in->linesize[1], 2);
225         thumbnail_kernel(s, s->cu_func_ushort2, s->cu_tex_uchar, 1,
226             histogram + 512, in->data[2], in->width, in->height, in->linesize[2], 2);
227         break;
228     default:
229         return AVERROR_BUG;
230     }
231
232     return 0;
233 }
234
235 static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
236 {
237     AVFilterContext *ctx  = inlink->dst;
238     ThumbnailCudaContext *s   = ctx->priv;
239     AVFilterLink *outlink = ctx->outputs[0];
240     int *hist = s->frames[s->n].histogram;
241     AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)s->hw_frames_ctx->data;
242     AVCUDADeviceContext *device_hwctx = hw_frames_ctx->device_ctx->hwctx;
243     CUcontext dummy;
244     CUDA_MEMCPY2D cpy = { 0 };
245     int ret = 0;
246
247     // keep a reference of each frame
248     s->frames[s->n].buf = frame;
249
250     ret = CHECK_CU(cuCtxPushCurrent(device_hwctx->cuda_ctx));
251     if (ret < 0)
252         return ret;
253
254     CHECK_CU(cuMemsetD8(s->data, 0, HIST_SIZE * sizeof(int)));
255
256     thumbnail(ctx, (int*)s->data, frame);
257
258     cpy.srcMemoryType = CU_MEMORYTYPE_DEVICE;
259     cpy.dstMemoryType = CU_MEMORYTYPE_HOST;
260     cpy.srcDevice = s->data;
261     cpy.dstHost = hist;
262     cpy.srcPitch = HIST_SIZE * sizeof(int);
263     cpy.dstPitch = HIST_SIZE * sizeof(int);
264     cpy.WidthInBytes = HIST_SIZE * sizeof(int);
265     cpy.Height = 1;
266
267     ret = CHECK_CU(cuMemcpy2D(&cpy));
268     if (ret < 0)
269         return ret;
270
271     if (hw_frames_ctx->sw_format == AV_PIX_FMT_NV12 || hw_frames_ctx->sw_format == AV_PIX_FMT_YUV420P ||
272         hw_frames_ctx->sw_format == AV_PIX_FMT_P010LE || hw_frames_ctx->sw_format == AV_PIX_FMT_P016LE)
273     {
274         int i;
275         for (i = 256; i < HIST_SIZE; i++)
276             hist[i] = 4 * hist[i];
277     }
278
279     CHECK_CU(cuCtxPopCurrent(&dummy));
280     if (ret < 0)
281         return ret;
282
283     // no selection until the buffer of N frames is filled up
284     s->n++;
285     if (s->n < s->n_frames)
286         return 0;
287
288     return ff_filter_frame(outlink, get_best_frame(ctx));
289 }
290
291 static av_cold void uninit(AVFilterContext *ctx)
292 {
293     int i;
294     ThumbnailCudaContext *s = ctx->priv;
295
296     if (s->data) {
297         CHECK_CU(cuMemFree(s->data));
298         s->data = 0;
299     }
300
301     if (s->cu_module) {
302         CHECK_CU(cuModuleUnload(s->cu_module));
303         s->cu_module = NULL;
304     }
305
306     for (i = 0; i < s->n_frames && s->frames[i].buf; i++)
307         av_frame_free(&s->frames[i].buf);
308     av_freep(&s->frames);
309 }
310
311 static int request_frame(AVFilterLink *link)
312 {
313     AVFilterContext *ctx = link->src;
314     ThumbnailCudaContext *s = ctx->priv;
315     int ret = ff_request_frame(ctx->inputs[0]);
316
317     if (ret == AVERROR_EOF && s->n) {
318         ret = ff_filter_frame(link, get_best_frame(ctx));
319         if (ret < 0)
320             return ret;
321         ret = AVERROR_EOF;
322     }
323     if (ret < 0)
324         return ret;
325     return 0;
326 }
327
328 static int format_is_supported(enum AVPixelFormat fmt)
329 {
330     int i;
331
332     for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++)
333         if (supported_formats[i] == fmt)
334             return 1;
335     return 0;
336 }
337
338 static int config_props(AVFilterLink *inlink)
339 {
340     AVFilterContext *ctx = inlink->dst;
341     ThumbnailCudaContext *s = ctx->priv;
342     AVHWFramesContext     *hw_frames_ctx = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
343     AVCUDADeviceContext *device_hwctx = hw_frames_ctx->device_ctx->hwctx;
344     CUcontext dummy, cuda_ctx = device_hwctx->cuda_ctx;
345     int ret;
346
347     extern char vf_thumbnail_cuda_ptx[];
348
349     ret = CHECK_CU(cuCtxPushCurrent(cuda_ctx));
350     if (ret < 0)
351         return ret;
352
353     ret = CHECK_CU(cuModuleLoadData(&s->cu_module, vf_thumbnail_cuda_ptx));
354     if (ret < 0)
355         return ret;
356
357     CHECK_CU(cuModuleGetFunction(&s->cu_func_uchar, s->cu_module, "Thumbnail_uchar"));
358     CHECK_CU(cuModuleGetFunction(&s->cu_func_uchar2, s->cu_module, "Thumbnail_uchar2"));
359     CHECK_CU(cuModuleGetFunction(&s->cu_func_ushort, s->cu_module, "Thumbnail_ushort"));
360     CHECK_CU(cuModuleGetFunction(&s->cu_func_ushort2, s->cu_module, "Thumbnail_ushort2"));
361
362     CHECK_CU(cuModuleGetTexRef(&s->cu_tex_uchar, s->cu_module, "uchar_tex"));
363     CHECK_CU(cuModuleGetTexRef(&s->cu_tex_uchar2, s->cu_module, "uchar2_tex"));
364     CHECK_CU(cuModuleGetTexRef(&s->cu_tex_ushort, s->cu_module, "ushort_tex"));
365     CHECK_CU(cuModuleGetTexRef(&s->cu_tex_ushort2, s->cu_module, "ushort2_tex"));
366
367     CHECK_CU(cuTexRefSetFlags(s->cu_tex_uchar, CU_TRSF_READ_AS_INTEGER));
368     CHECK_CU(cuTexRefSetFlags(s->cu_tex_uchar2, CU_TRSF_READ_AS_INTEGER));
369     CHECK_CU(cuTexRefSetFlags(s->cu_tex_ushort, CU_TRSF_READ_AS_INTEGER));
370     CHECK_CU(cuTexRefSetFlags(s->cu_tex_ushort2, CU_TRSF_READ_AS_INTEGER));
371
372     CHECK_CU(cuTexRefSetFilterMode(s->cu_tex_uchar, CU_TR_FILTER_MODE_LINEAR));
373     CHECK_CU(cuTexRefSetFilterMode(s->cu_tex_uchar2, CU_TR_FILTER_MODE_LINEAR));
374     CHECK_CU(cuTexRefSetFilterMode(s->cu_tex_ushort, CU_TR_FILTER_MODE_LINEAR));
375     CHECK_CU(cuTexRefSetFilterMode(s->cu_tex_ushort2, CU_TR_FILTER_MODE_LINEAR));
376
377     ret = CHECK_CU(cuMemAlloc(&s->data, HIST_SIZE * sizeof(int)));
378     if (ret < 0)
379         return ret;
380
381     CHECK_CU(cuCtxPopCurrent(&dummy));
382
383     s->hw_frames_ctx = ctx->inputs[0]->hw_frames_ctx;
384
385     ctx->outputs[0]->hw_frames_ctx = av_buffer_ref(s->hw_frames_ctx);
386     if (!ctx->outputs[0]->hw_frames_ctx)
387         return AVERROR(ENOMEM);
388
389     s->tb = inlink->time_base;
390
391     if (!format_is_supported(hw_frames_ctx->sw_format)) {
392         av_log(ctx, AV_LOG_ERROR, "Unsupported input format: %s\n", av_get_pix_fmt_name(hw_frames_ctx->sw_format));
393         return AVERROR(ENOSYS);
394     }
395
396     return 0;
397 }
398
399 static int query_formats(AVFilterContext *ctx)
400 {
401     static const enum AVPixelFormat pix_fmts[] = {
402         AV_PIX_FMT_CUDA,
403         AV_PIX_FMT_NONE
404     };
405     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
406     if (!fmts_list)
407         return AVERROR(ENOMEM);
408     return ff_set_common_formats(ctx, fmts_list);
409 }
410
411 static const AVFilterPad thumbnail_cuda_inputs[] = {
412     {
413         .name         = "default",
414         .type         = AVMEDIA_TYPE_VIDEO,
415         .config_props = config_props,
416         .filter_frame = filter_frame,
417     },
418     { NULL }
419 };
420
421 static const AVFilterPad thumbnail_cuda_outputs[] = {
422     {
423         .name          = "default",
424         .type          = AVMEDIA_TYPE_VIDEO,
425         .request_frame = request_frame,
426     },
427     { NULL }
428 };
429
430 AVFilter ff_vf_thumbnail_cuda = {
431     .name          = "thumbnail_cuda",
432     .description   = NULL_IF_CONFIG_SMALL("Select the most representative frame in a given sequence of consecutive frames."),
433     .priv_size     = sizeof(ThumbnailCudaContext),
434     .init          = init,
435     .uninit        = uninit,
436     .query_formats = query_formats,
437     .inputs        = thumbnail_cuda_inputs,
438     .outputs       = thumbnail_cuda_outputs,
439     .priv_class    = &thumbnail_cuda_class,
440     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
441 };