libavcodec/zmbvenc: block scoring improvements/bug fixes
[ffmpeg.git] / libavcodec / v4l2_m2m.c
1 /*
2  * V4L mem2mem
3  *
4  * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
5  * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 #include <linux/videodev2.h>
25 #include <sys/ioctl.h>
26 #include <sys/mman.h>
27 #include <unistd.h>
28 #include <dirent.h>
29 #include <fcntl.h>
30 #include "libavcodec/avcodec.h"
31 #include "libavcodec/internal.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/pixfmt.h"
35 #include "v4l2_context.h"
36 #include "v4l2_fmt.h"
37 #include "v4l2_m2m.h"
38
39 static inline int v4l2_splane_video(struct v4l2_capability *cap)
40 {
41     if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT) &&
42         cap->capabilities & V4L2_CAP_STREAMING)
43         return 1;
44
45     if (cap->capabilities & V4L2_CAP_VIDEO_M2M)
46         return 1;
47
48     return 0;
49 }
50
51 static inline int v4l2_mplane_video(struct v4l2_capability *cap)
52 {
53     if (cap->capabilities & (V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_VIDEO_OUTPUT_MPLANE) &&
54         cap->capabilities & V4L2_CAP_STREAMING)
55         return 1;
56
57     if (cap->capabilities & V4L2_CAP_VIDEO_M2M_MPLANE)
58         return 1;
59
60     return 0;
61 }
62
63 static int v4l2_prepare_contexts(V4L2m2mContext* s)
64 {
65     struct v4l2_capability cap;
66     int ret;
67
68     s->capture.done = s->output.done = 0;
69     s->capture.name = "capture";
70     s->output.name = "output ";
71     atomic_init(&s->refcount, 0);
72     sem_init(&s->refsync, 0, 0);
73
74     memset(&cap, 0, sizeof(cap));
75     ret = ioctl(s->fd, VIDIOC_QUERYCAP, &cap);
76     if (ret < 0)
77         return ret;
78
79     av_log(s->avctx, AV_LOG_INFO, "driver '%s' on card '%s'\n", cap.driver, cap.card);
80
81     if (v4l2_mplane_video(&cap)) {
82         s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
83         s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
84         return 0;
85     }
86
87     if (v4l2_splane_video(&cap)) {
88         s->capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
89         s->output.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
90         return 0;
91     }
92
93     return AVERROR(EINVAL);
94 }
95
96 static int v4l2_probe_driver(V4L2m2mContext* s)
97 {
98     int ret;
99
100     s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
101     if (s->fd < 0)
102         return AVERROR(errno);
103
104     ret = v4l2_prepare_contexts(s);
105     if (ret < 0)
106         goto done;
107
108     ret = ff_v4l2_context_get_format(&s->output);
109     if (ret) {
110         av_log(s->avctx, AV_LOG_DEBUG, "v4l2 output format not supported\n");
111         goto done;
112     }
113
114     ret = ff_v4l2_context_get_format(&s->capture);
115     if (ret) {
116         av_log(s->avctx, AV_LOG_DEBUG, "v4l2 capture format not supported\n");
117         goto done;
118     }
119
120 done:
121     if (close(s->fd) < 0) {
122         ret = AVERROR(errno);
123         av_log(s->avctx, AV_LOG_ERROR, "failure closing %s (%s)\n", s->devname, av_err2str(AVERROR(errno)));
124     }
125
126     s->fd = -1;
127
128     return ret;
129 }
130
131 static int v4l2_configure_contexts(V4L2m2mContext* s)
132 {
133     void *log_ctx = s->avctx;
134     int ret;
135
136     s->fd = open(s->devname, O_RDWR | O_NONBLOCK, 0);
137     if (s->fd < 0)
138         return AVERROR(errno);
139
140     ret = v4l2_prepare_contexts(s);
141     if (ret < 0)
142         goto error;
143
144     ret = ff_v4l2_context_set_format(&s->output);
145     if (ret) {
146         av_log(log_ctx, AV_LOG_ERROR, "can't set v4l2 output format\n");
147         goto error;
148     }
149
150     ret = ff_v4l2_context_set_format(&s->capture);
151     if (ret) {
152         av_log(log_ctx, AV_LOG_ERROR, "can't to set v4l2 capture format\n");
153         goto error;
154     }
155
156     ret = ff_v4l2_context_init(&s->output);
157     if (ret) {
158         av_log(log_ctx, AV_LOG_ERROR, "no v4l2 output context's buffers\n");
159         goto error;
160     }
161
162     /* decoder's buffers need to be updated at a later stage */
163     if (!av_codec_is_decoder(s->avctx->codec)) {
164         ret = ff_v4l2_context_init(&s->capture);
165         if (ret) {
166             av_log(log_ctx, AV_LOG_ERROR, "no v4l2 capture context's buffers\n");
167             goto error;
168         }
169     }
170
171     return 0;
172
173 error:
174     if (close(s->fd) < 0) {
175         ret = AVERROR(errno);
176         av_log(log_ctx, AV_LOG_ERROR, "error closing %s (%s)\n",
177             s->devname, av_err2str(AVERROR(errno)));
178     }
179     s->fd = -1;
180
181     return ret;
182 }
183
184 /******************************************************************************
185  *
186  *                  V4L2 M2M Interface
187  *
188  ******************************************************************************/
189 int ff_v4l2_m2m_codec_reinit(V4L2m2mContext* s)
190 {
191     int ret;
192
193     av_log(s->avctx, AV_LOG_DEBUG, "reinit context\n");
194
195     /* 1. streamoff */
196     ret = ff_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF);
197     if (ret)
198         av_log(s->avctx, AV_LOG_ERROR, "capture VIDIOC_STREAMOFF\n");
199
200     /* 2. unmap the capture buffers (v4l2 and ffmpeg):
201      *    we must wait for all references to be released before being allowed
202      *    to queue new buffers.
203      */
204     av_log(s->avctx, AV_LOG_DEBUG, "waiting for user to release AVBufferRefs\n");
205     if (atomic_load(&s->refcount))
206         while(sem_wait(&s->refsync) == -1 && errno == EINTR);
207
208     ff_v4l2_context_release(&s->capture);
209
210     /* 3. get the new capture format */
211     ret = ff_v4l2_context_get_format(&s->capture);
212     if (ret) {
213         av_log(s->avctx, AV_LOG_ERROR, "query the new capture format\n");
214         return ret;
215     }
216
217     /* 4. set the capture format */
218     ret = ff_v4l2_context_set_format(&s->capture);
219     if (ret) {
220         av_log(s->avctx, AV_LOG_ERROR, "setting capture format\n");
221         return ret;
222     }
223
224     /* 5. complete reinit */
225     s->draining = 0;
226     s->reinit = 0;
227
228     return 0;
229 }
230
231 int ff_v4l2_m2m_codec_full_reinit(V4L2m2mContext *s)
232 {
233     void *log_ctx = s->avctx;
234     int ret;
235
236     av_log(log_ctx, AV_LOG_DEBUG, "%s full reinit\n", s->devname);
237
238     /* wait for pending buffer references */
239     if (atomic_load(&s->refcount))
240         while(sem_wait(&s->refsync) == -1 && errno == EINTR);
241
242     ret = ff_v4l2_context_set_status(&s->output, VIDIOC_STREAMOFF);
243     if (ret) {
244         av_log(s->avctx, AV_LOG_ERROR, "output VIDIOC_STREAMOFF\n");
245         goto error;
246     }
247
248     ret = ff_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF);
249     if (ret) {
250             av_log(s->avctx, AV_LOG_ERROR, "capture VIDIOC_STREAMOFF\n");
251             goto error;
252     }
253
254     /* release and unmmap the buffers */
255     ff_v4l2_context_release(&s->output);
256     ff_v4l2_context_release(&s->capture);
257
258     /* start again now that we know the stream dimensions */
259     s->draining = 0;
260     s->reinit = 0;
261
262     ret = ff_v4l2_context_get_format(&s->output);
263     if (ret) {
264         av_log(log_ctx, AV_LOG_DEBUG, "v4l2 output format not supported\n");
265         goto error;
266     }
267
268     ret = ff_v4l2_context_get_format(&s->capture);
269     if (ret) {
270         av_log(log_ctx, AV_LOG_DEBUG, "v4l2 capture format not supported\n");
271         goto error;
272     }
273
274     ret = ff_v4l2_context_set_format(&s->output);
275     if (ret) {
276         av_log(log_ctx, AV_LOG_ERROR, "can't set v4l2 output format\n");
277         goto error;
278     }
279
280     ret = ff_v4l2_context_set_format(&s->capture);
281     if (ret) {
282         av_log(log_ctx, AV_LOG_ERROR, "can't to set v4l2 capture format\n");
283         goto error;
284     }
285
286     ret = ff_v4l2_context_init(&s->output);
287     if (ret) {
288         av_log(log_ctx, AV_LOG_ERROR, "no v4l2 output context's buffers\n");
289         goto error;
290     }
291
292     /* decoder's buffers need to be updated at a later stage */
293     if (!av_codec_is_decoder(s->avctx->codec)) {
294         ret = ff_v4l2_context_init(&s->capture);
295         if (ret) {
296             av_log(log_ctx, AV_LOG_ERROR, "no v4l2 capture context's buffers\n");
297             goto error;
298         }
299     }
300
301     return 0;
302
303 error:
304     return ret;
305 }
306
307 static void v4l2_m2m_destroy_context(void *opaque, uint8_t *context)
308 {
309     V4L2m2mContext *s = (V4L2m2mContext*)context;
310
311     ff_v4l2_context_release(&s->capture);
312     sem_destroy(&s->refsync);
313
314     close(s->fd);
315
316     av_free(s);
317 }
318
319 int ff_v4l2_m2m_codec_end(AVCodecContext *avctx)
320 {
321     V4L2m2mPriv *priv = avctx->priv_data;
322     V4L2m2mContext* s = priv->context;
323     int ret;
324
325     ret = ff_v4l2_context_set_status(&s->output, VIDIOC_STREAMOFF);
326     if (ret)
327             av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF %s\n", s->output.name);
328
329     ret = ff_v4l2_context_set_status(&s->capture, VIDIOC_STREAMOFF);
330     if (ret)
331         av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMOFF %s\n", s->capture.name);
332
333     ff_v4l2_context_release(&s->output);
334
335     s->self_ref = NULL;
336     av_buffer_unref(&priv->context_ref);
337
338     return 0;
339 }
340
341 int ff_v4l2_m2m_codec_init(AVCodecContext *avctx)
342 {
343     int ret = AVERROR(EINVAL);
344     struct dirent *entry;
345     char node[PATH_MAX];
346     DIR *dirp;
347
348     V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
349     s->avctx = avctx;
350
351     dirp = opendir("/dev");
352     if (!dirp)
353         return AVERROR(errno);
354
355     for (entry = readdir(dirp); entry; entry = readdir(dirp)) {
356
357         if (strncmp(entry->d_name, "video", 5))
358             continue;
359
360         snprintf(node, sizeof(node), "/dev/%s", entry->d_name);
361         av_log(s->avctx, AV_LOG_DEBUG, "probing device %s\n", node);
362         strncpy(s->devname, node, strlen(node) + 1);
363         ret = v4l2_probe_driver(s);
364         if (!ret)
365                 break;
366     }
367
368     closedir(dirp);
369
370     if (ret) {
371         av_log(s->avctx, AV_LOG_ERROR, "Could not find a valid device\n");
372         memset(s->devname, 0, sizeof(s->devname));
373
374         return ret;
375     }
376
377     av_log(s->avctx, AV_LOG_INFO, "Using device %s\n", node);
378
379     return v4l2_configure_contexts(s);
380 }
381
382 int ff_v4l2_m2m_create_context(AVCodecContext *avctx, V4L2m2mContext **s)
383 {
384     V4L2m2mPriv *priv = avctx->priv_data;
385
386     *s = av_mallocz(sizeof(V4L2m2mContext));
387     if (!*s)
388         return AVERROR(ENOMEM);
389
390     priv->context_ref = av_buffer_create((uint8_t *) *s, sizeof(V4L2m2mContext),
391                                          &v4l2_m2m_destroy_context, NULL, 0);
392     if (!priv->context_ref) {
393         av_freep(s);
394         return AVERROR(ENOMEM);
395     }
396
397     /* assign the context */
398     priv->context = *s;
399
400     /* populate it */
401     priv->context->capture.num_buffers = priv->num_capture_buffers;
402     priv->context->output.num_buffers  = priv->num_output_buffers;
403     priv->context->self_ref = priv->context_ref;
404
405     return 0;
406 }