GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/v4l2_context.c Lines: 0 385 0.0 %
Date: 2020-09-25 14:59:26 Branches: 0 360 0.0 %

Line Branch Exec Source
1
/*
2
 * V4L2 context helper functions.
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 <fcntl.h>
29
#include <poll.h>
30
#include "libavcodec/avcodec.h"
31
#include "libavcodec/internal.h"
32
#include "v4l2_buffers.h"
33
#include "v4l2_fmt.h"
34
#include "v4l2_m2m.h"
35
36
struct v4l2_format_update {
37
    uint32_t v4l2_fmt;
38
    int update_v4l2;
39
40
    enum AVPixelFormat av_fmt;
41
    int update_avfmt;
42
};
43
44
static inline V4L2m2mContext *ctx_to_m2mctx(V4L2Context *ctx)
45
{
46
    return V4L2_TYPE_IS_OUTPUT(ctx->type) ?
47
        container_of(ctx, V4L2m2mContext, output) :
48
        container_of(ctx, V4L2m2mContext, capture);
49
}
50
51
static inline AVCodecContext *logger(V4L2Context *ctx)
52
{
53
    return ctx_to_m2mctx(ctx)->avctx;
54
}
55
56
static inline unsigned int v4l2_get_width(struct v4l2_format *fmt)
57
{
58
    return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.width : fmt->fmt.pix.width;
59
}
60
61
static inline unsigned int v4l2_get_height(struct v4l2_format *fmt)
62
{
63
    return V4L2_TYPE_IS_MULTIPLANAR(fmt->type) ? fmt->fmt.pix_mp.height : fmt->fmt.pix.height;
64
}
65
66
static AVRational v4l2_get_sar(V4L2Context *ctx)
67
{
68
    struct AVRational sar = { 0, 1 };
69
    struct v4l2_cropcap cropcap;
70
    int ret;
71
72
    memset(&cropcap, 0, sizeof(cropcap));
73
    cropcap.type = ctx->type;
74
75
    ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_CROPCAP, &cropcap);
76
    if (ret)
77
        return sar;
78
79
    sar.num = cropcap.pixelaspect.numerator;
80
    sar.den = cropcap.pixelaspect.denominator;
81
    return sar;
82
}
83
84
static inline unsigned int v4l2_resolution_changed(V4L2Context *ctx, struct v4l2_format *fmt2)
85
{
86
    struct v4l2_format *fmt1 = &ctx->format;
87
    int ret =  V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ?
88
        fmt1->fmt.pix_mp.width != fmt2->fmt.pix_mp.width ||
89
        fmt1->fmt.pix_mp.height != fmt2->fmt.pix_mp.height
90
        :
91
        fmt1->fmt.pix.width != fmt2->fmt.pix.width ||
92
        fmt1->fmt.pix.height != fmt2->fmt.pix.height;
93
94
    if (ret)
95
        av_log(logger(ctx), AV_LOG_DEBUG, "%s changed (%dx%d) -> (%dx%d)\n",
96
            ctx->name,
97
            v4l2_get_width(fmt1), v4l2_get_height(fmt1),
98
            v4l2_get_width(fmt2), v4l2_get_height(fmt2));
99
100
    return ret;
101
}
102
103
static inline int v4l2_type_supported(V4L2Context *ctx)
104
{
105
    return ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
106
        ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
107
        ctx->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
108
        ctx->type == V4L2_BUF_TYPE_VIDEO_OUTPUT;
109
}
110
111
static inline int v4l2_get_framesize_compressed(V4L2Context* ctx, int width, int height)
112
{
113
    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
114
    const int SZ_4K = 0x1000;
115
    int size;
116
117
    if (s->avctx && av_codec_is_decoder(s->avctx->codec))
118
        return ((width * height * 3 / 2) / 2) + 128;
119
120
    /* encoder */
121
    size = FFALIGN(height, 32) * FFALIGN(width, 32) * 3 / 2 / 2;
122
    return FFALIGN(size, SZ_4K);
123
}
124
125
static inline void v4l2_save_to_context(V4L2Context* ctx, struct v4l2_format_update *fmt)
126
{
127
    ctx->format.type = ctx->type;
128
129
    if (fmt->update_avfmt)
130
        ctx->av_pix_fmt = fmt->av_fmt;
131
132
    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
133
        /* update the sizes to handle the reconfiguration of the capture stream at runtime */
134
        ctx->format.fmt.pix_mp.height = ctx->height;
135
        ctx->format.fmt.pix_mp.width = ctx->width;
136
        if (fmt->update_v4l2) {
137
            ctx->format.fmt.pix_mp.pixelformat = fmt->v4l2_fmt;
138
139
            /* s5p-mfc requires the user to specify a buffer size */
140
            ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage =
141
                v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
142
        }
143
    } else {
144
        ctx->format.fmt.pix.height = ctx->height;
145
        ctx->format.fmt.pix.width = ctx->width;
146
        if (fmt->update_v4l2) {
147
            ctx->format.fmt.pix.pixelformat = fmt->v4l2_fmt;
148
149
            /* s5p-mfc requires the user to specify a buffer size */
150
            ctx->format.fmt.pix.sizeimage =
151
                v4l2_get_framesize_compressed(ctx, ctx->width, ctx->height);
152
        }
153
    }
154
}
155
156
/**
157
 * handle resolution change event and end of stream event
158
 * returns 1 if reinit was successful, negative if it failed
159
 * returns 0 if reinit was not executed
160
 */
161
static int v4l2_handle_event(V4L2Context *ctx)
162
{
163
    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
164
    struct v4l2_format cap_fmt = s->capture.format;
165
    struct v4l2_format out_fmt = s->output.format;
166
    struct v4l2_event evt = { 0 };
167
    int full_reinit, reinit, ret;
168
169
    ret = ioctl(s->fd, VIDIOC_DQEVENT, &evt);
170
    if (ret < 0) {
171
        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_DQEVENT\n", ctx->name);
172
        return 0;
173
    }
174
175
    if (evt.type == V4L2_EVENT_EOS) {
176
        ctx->done = 1;
177
        return 0;
178
    }
179
180
    if (evt.type != V4L2_EVENT_SOURCE_CHANGE)
181
        return 0;
182
183
    ret = ioctl(s->fd, VIDIOC_G_FMT, &out_fmt);
184
    if (ret) {
185
        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->output.name);
186
        return 0;
187
    }
188
189
    ret = ioctl(s->fd, VIDIOC_G_FMT, &cap_fmt);
190
    if (ret) {
191
        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT\n", s->capture.name);
192
        return 0;
193
    }
194
195
    full_reinit = v4l2_resolution_changed(&s->output, &out_fmt);
196
    if (full_reinit) {
197
        s->output.height = v4l2_get_height(&out_fmt);
198
        s->output.width = v4l2_get_width(&out_fmt);
199
        s->output.sample_aspect_ratio = v4l2_get_sar(&s->output);
200
    }
201
202
    reinit = v4l2_resolution_changed(&s->capture, &cap_fmt);
203
    if (reinit) {
204
        s->capture.height = v4l2_get_height(&cap_fmt);
205
        s->capture.width = v4l2_get_width(&cap_fmt);
206
        s->capture.sample_aspect_ratio = v4l2_get_sar(&s->capture);
207
    }
208
209
    if (full_reinit || reinit)
210
        s->reinit = 1;
211
212
    if (full_reinit) {
213
        ret = ff_v4l2_m2m_codec_full_reinit(s);
214
        if (ret) {
215
            av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_full_reinit\n");
216
            return AVERROR(EINVAL);
217
        }
218
        goto reinit_run;
219
    }
220
221
    if (reinit) {
222
        if (s->avctx)
223
            ret = ff_set_dimensions(s->avctx, s->capture.width, s->capture.height);
224
        if (ret < 0)
225
            av_log(logger(ctx), AV_LOG_WARNING, "update avcodec height and width\n");
226
227
        ret = ff_v4l2_m2m_codec_reinit(s);
228
        if (ret) {
229
            av_log(logger(ctx), AV_LOG_ERROR, "v4l2_m2m_codec_reinit\n");
230
            return AVERROR(EINVAL);
231
        }
232
        goto reinit_run;
233
    }
234
235
    /* dummy event received */
236
    return 0;
237
238
    /* reinit executed */
239
reinit_run:
240
    return 1;
241
}
242
243
static int v4l2_stop_decode(V4L2Context *ctx)
244
{
245
    struct v4l2_decoder_cmd cmd = {
246
        .cmd = V4L2_DEC_CMD_STOP,
247
        .flags = 0,
248
    };
249
    int ret;
250
251
    ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DECODER_CMD, &cmd);
252
    if (ret) {
253
        /* DECODER_CMD is optional */
254
        if (errno == ENOTTY)
255
            return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
256
        else
257
            return AVERROR(errno);
258
    }
259
260
    return 0;
261
}
262
263
static int v4l2_stop_encode(V4L2Context *ctx)
264
{
265
    struct v4l2_encoder_cmd cmd = {
266
        .cmd = V4L2_ENC_CMD_STOP,
267
        .flags = 0,
268
    };
269
    int ret;
270
271
    ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENCODER_CMD, &cmd);
272
    if (ret) {
273
        /* ENCODER_CMD is optional */
274
        if (errno == ENOTTY)
275
            return ff_v4l2_context_set_status(ctx, VIDIOC_STREAMOFF);
276
        else
277
            return AVERROR(errno);
278
    }
279
280
    return 0;
281
}
282
283
static V4L2Buffer* v4l2_dequeue_v4l2buf(V4L2Context *ctx, int timeout)
284
{
285
    struct v4l2_plane planes[VIDEO_MAX_PLANES];
286
    struct v4l2_buffer buf = { 0 };
287
    V4L2Buffer *avbuf;
288
    struct pollfd pfd = {
289
        .events =  POLLIN | POLLRDNORM | POLLPRI | POLLOUT | POLLWRNORM, /* default blocking capture */
290
        .fd = ctx_to_m2mctx(ctx)->fd,
291
    };
292
    int i, ret;
293
294
    if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx->buffers) {
295
        for (i = 0; i < ctx->num_buffers; i++) {
296
            if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
297
                break;
298
        }
299
        if (i == ctx->num_buffers)
300
            av_log(logger(ctx), AV_LOG_WARNING, "All capture buffers returned to "
301
                                                "userspace. Increase num_capture_buffers "
302
                                                "to prevent device deadlock or dropped "
303
                                                "packets/frames.\n");
304
    }
305
306
    /* if we are draining and there are no more capture buffers queued in the driver we are done */
307
    if (!V4L2_TYPE_IS_OUTPUT(ctx->type) && ctx_to_m2mctx(ctx)->draining) {
308
        for (i = 0; i < ctx->num_buffers; i++) {
309
            /* capture buffer initialization happens during decode hence
310
             * detection happens at runtime
311
             */
312
            if (!ctx->buffers)
313
                break;
314
315
            if (ctx->buffers[i].status == V4L2BUF_IN_DRIVER)
316
                goto start;
317
        }
318
        ctx->done = 1;
319
        return NULL;
320
    }
321
322
start:
323
    if (V4L2_TYPE_IS_OUTPUT(ctx->type))
324
        pfd.events =  POLLOUT | POLLWRNORM;
325
    else {
326
        /* no need to listen to requests for more input while draining */
327
        if (ctx_to_m2mctx(ctx)->draining)
328
            pfd.events =  POLLIN | POLLRDNORM | POLLPRI;
329
    }
330
331
    for (;;) {
332
        ret = poll(&pfd, 1, timeout);
333
        if (ret > 0)
334
            break;
335
        if (errno == EINTR)
336
            continue;
337
        return NULL;
338
    }
339
340
    /* 0. handle errors */
341
    if (pfd.revents & POLLERR) {
342
        /* if we are trying to get free buffers but none have been queued yet
343
           no need to raise a warning */
344
        if (timeout == 0) {
345
            for (i = 0; i < ctx->num_buffers; i++) {
346
                if (ctx->buffers[i].status != V4L2BUF_AVAILABLE)
347
                    av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
348
            }
349
        }
350
        else
351
            av_log(logger(ctx), AV_LOG_WARNING, "%s POLLERR\n", ctx->name);
352
353
        return NULL;
354
    }
355
356
    /* 1. handle resolution changes */
357
    if (pfd.revents & POLLPRI) {
358
        ret = v4l2_handle_event(ctx);
359
        if (ret < 0) {
360
            /* if re-init failed, abort */
361
            ctx->done = 1;
362
            return NULL;
363
        }
364
        if (ret) {
365
            /* if re-init was successful drop the buffer (if there was one)
366
             * since we had to reconfigure capture (unmap all buffers)
367
             */
368
            return NULL;
369
        }
370
    }
371
372
    /* 2. dequeue the buffer */
373
    if (pfd.revents & (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM)) {
374
375
        if (!V4L2_TYPE_IS_OUTPUT(ctx->type)) {
376
            /* there is a capture buffer ready */
377
            if (pfd.revents & (POLLIN | POLLRDNORM))
378
                goto dequeue;
379
380
            /* the driver is ready to accept more input; instead of waiting for the capture
381
             * buffer to complete we return NULL so input can proceed (we are single threaded)
382
             */
383
            if (pfd.revents & (POLLOUT | POLLWRNORM))
384
                return NULL;
385
        }
386
387
dequeue:
388
        memset(&buf, 0, sizeof(buf));
389
        buf.memory = V4L2_MEMORY_MMAP;
390
        buf.type = ctx->type;
391
        if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
392
            memset(planes, 0, sizeof(planes));
393
            buf.length = VIDEO_MAX_PLANES;
394
            buf.m.planes = planes;
395
        }
396
397
        ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_DQBUF, &buf);
398
        if (ret) {
399
            if (errno != EAGAIN) {
400
                ctx->done = 1;
401
                if (errno != EPIPE)
402
                    av_log(logger(ctx), AV_LOG_DEBUG, "%s VIDIOC_DQBUF, errno (%s)\n",
403
                        ctx->name, av_err2str(AVERROR(errno)));
404
            }
405
            return NULL;
406
        }
407
408
        if (ctx_to_m2mctx(ctx)->draining && !V4L2_TYPE_IS_OUTPUT(ctx->type)) {
409
            int bytesused = V4L2_TYPE_IS_MULTIPLANAR(buf.type) ?
410
                            buf.m.planes[0].bytesused : buf.bytesused;
411
            if (bytesused == 0) {
412
                ctx->done = 1;
413
                return NULL;
414
            }
415
#ifdef V4L2_BUF_FLAG_LAST
416
            if (buf.flags & V4L2_BUF_FLAG_LAST)
417
                ctx->done = 1;
418
#endif
419
        }
420
421
        avbuf = &ctx->buffers[buf.index];
422
        avbuf->status = V4L2BUF_AVAILABLE;
423
        avbuf->buf = buf;
424
        if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type)) {
425
            memcpy(avbuf->planes, planes, sizeof(planes));
426
            avbuf->buf.m.planes = avbuf->planes;
427
        }
428
        return avbuf;
429
    }
430
431
    return NULL;
432
}
433
434
static V4L2Buffer* v4l2_getfree_v4l2buf(V4L2Context *ctx)
435
{
436
    int timeout = 0; /* return when no more buffers to dequeue */
437
    int i;
438
439
    /* get back as many output buffers as possible */
440
    if (V4L2_TYPE_IS_OUTPUT(ctx->type)) {
441
          do {
442
          } while (v4l2_dequeue_v4l2buf(ctx, timeout));
443
    }
444
445
    for (i = 0; i < ctx->num_buffers; i++) {
446
        if (ctx->buffers[i].status == V4L2BUF_AVAILABLE)
447
            return &ctx->buffers[i];
448
    }
449
450
    return NULL;
451
}
452
453
static int v4l2_release_buffers(V4L2Context* ctx)
454
{
455
    struct v4l2_requestbuffers req = {
456
        .memory = V4L2_MEMORY_MMAP,
457
        .type = ctx->type,
458
        .count = 0, /* 0 -> unmaps buffers from the driver */
459
    };
460
    int i, j;
461
462
    for (i = 0; i < ctx->num_buffers; i++) {
463
        V4L2Buffer *buffer = &ctx->buffers[i];
464
465
        for (j = 0; j < buffer->num_planes; j++) {
466
            struct V4L2Plane_info *p = &buffer->plane_info[j];
467
            if (p->mm_addr && p->length)
468
                if (munmap(p->mm_addr, p->length) < 0)
469
                    av_log(logger(ctx), AV_LOG_ERROR, "%s unmap plane (%s))\n", ctx->name, av_err2str(AVERROR(errno)));
470
        }
471
    }
472
473
    return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_REQBUFS, &req);
474
}
475
476
static inline int v4l2_try_raw_format(V4L2Context* ctx, enum AVPixelFormat pixfmt)
477
{
478
    struct v4l2_format *fmt = &ctx->format;
479
    uint32_t v4l2_fmt;
480
    int ret;
481
482
    v4l2_fmt = ff_v4l2_format_avfmt_to_v4l2(pixfmt);
483
    if (!v4l2_fmt)
484
        return AVERROR(EINVAL);
485
486
    if (V4L2_TYPE_IS_MULTIPLANAR(ctx->type))
487
        fmt->fmt.pix_mp.pixelformat = v4l2_fmt;
488
    else
489
        fmt->fmt.pix.pixelformat = v4l2_fmt;
490
491
    fmt->type = ctx->type;
492
493
    ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, fmt);
494
    if (ret)
495
        return AVERROR(EINVAL);
496
497
    return 0;
498
}
499
500
static int v4l2_get_raw_format(V4L2Context* ctx, enum AVPixelFormat *p)
501
{
502
    enum AVPixelFormat pixfmt = ctx->av_pix_fmt;
503
    struct v4l2_fmtdesc fdesc;
504
    int ret;
505
506
    memset(&fdesc, 0, sizeof(fdesc));
507
    fdesc.type = ctx->type;
508
509
    if (pixfmt != AV_PIX_FMT_NONE) {
510
        ret = v4l2_try_raw_format(ctx, pixfmt);
511
        if (!ret)
512
            return 0;
513
    }
514
515
    for (;;) {
516
        ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
517
        if (ret)
518
            return AVERROR(EINVAL);
519
520
        pixfmt = ff_v4l2_format_v4l2_to_avfmt(fdesc.pixelformat, AV_CODEC_ID_RAWVIDEO);
521
        ret = v4l2_try_raw_format(ctx, pixfmt);
522
        if (ret){
523
            fdesc.index++;
524
            continue;
525
        }
526
527
        *p = pixfmt;
528
529
        return 0;
530
    }
531
532
    return AVERROR(EINVAL);
533
}
534
535
static int v4l2_get_coded_format(V4L2Context* ctx, uint32_t *p)
536
{
537
    struct v4l2_fmtdesc fdesc;
538
    uint32_t v4l2_fmt;
539
    int ret;
540
541
    /* translate to a valid v4l2 format */
542
    v4l2_fmt = ff_v4l2_format_avcodec_to_v4l2(ctx->av_codec_id);
543
    if (!v4l2_fmt)
544
        return AVERROR(EINVAL);
545
546
    /* check if the driver supports this format */
547
    memset(&fdesc, 0, sizeof(fdesc));
548
    fdesc.type = ctx->type;
549
550
    for (;;) {
551
        ret = ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_ENUM_FMT, &fdesc);
552
        if (ret)
553
            return AVERROR(EINVAL);
554
555
        if (fdesc.pixelformat == v4l2_fmt)
556
            break;
557
558
        fdesc.index++;
559
    }
560
561
    *p = v4l2_fmt;
562
563
    return 0;
564
}
565
566
 /*****************************************************************************
567
  *
568
  *             V4L2 Context Interface
569
  *
570
  *****************************************************************************/
571
572
int ff_v4l2_context_set_status(V4L2Context* ctx, uint32_t cmd)
573
{
574
    int type = ctx->type;
575
    int ret;
576
577
    ret = ioctl(ctx_to_m2mctx(ctx)->fd, cmd, &type);
578
    if (ret < 0)
579
        return AVERROR(errno);
580
581
    ctx->streamon = (cmd == VIDIOC_STREAMON);
582
583
    return 0;
584
}
585
586
int ff_v4l2_context_enqueue_frame(V4L2Context* ctx, const AVFrame* frame)
587
{
588
    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
589
    V4L2Buffer* avbuf;
590
    int ret;
591
592
    if (!frame) {
593
        ret = v4l2_stop_encode(ctx);
594
        if (ret)
595
            av_log(logger(ctx), AV_LOG_ERROR, "%s stop_encode\n", ctx->name);
596
        s->draining= 1;
597
        return 0;
598
    }
599
600
    avbuf = v4l2_getfree_v4l2buf(ctx);
601
    if (!avbuf)
602
        return AVERROR(EAGAIN);
603
604
    ret = ff_v4l2_buffer_avframe_to_buf(frame, avbuf);
605
    if (ret)
606
        return ret;
607
608
    return ff_v4l2_buffer_enqueue(avbuf);
609
}
610
611
int ff_v4l2_context_enqueue_packet(V4L2Context* ctx, const AVPacket* pkt)
612
{
613
    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
614
    V4L2Buffer* avbuf;
615
    int ret;
616
617
    if (!pkt->size) {
618
        ret = v4l2_stop_decode(ctx);
619
        if (ret)
620
            av_log(logger(ctx), AV_LOG_ERROR, "%s stop_decode\n", ctx->name);
621
        s->draining = 1;
622
        return 0;
623
    }
624
625
    avbuf = v4l2_getfree_v4l2buf(ctx);
626
    if (!avbuf)
627
        return AVERROR(EAGAIN);
628
629
    ret = ff_v4l2_buffer_avpkt_to_buf(pkt, avbuf);
630
    if (ret)
631
        return ret;
632
633
    return ff_v4l2_buffer_enqueue(avbuf);
634
}
635
636
int ff_v4l2_context_dequeue_frame(V4L2Context* ctx, AVFrame* frame, int timeout)
637
{
638
    V4L2Buffer *avbuf;
639
640
    /*
641
     * timeout=-1 blocks until:
642
     *  1. decoded frame available
643
     *  2. an input buffer is ready to be dequeued
644
     */
645
    avbuf = v4l2_dequeue_v4l2buf(ctx, timeout);
646
    if (!avbuf) {
647
        if (ctx->done)
648
            return AVERROR_EOF;
649
650
        return AVERROR(EAGAIN);
651
    }
652
653
    return ff_v4l2_buffer_buf_to_avframe(frame, avbuf);
654
}
655
656
int ff_v4l2_context_dequeue_packet(V4L2Context* ctx, AVPacket* pkt)
657
{
658
    V4L2Buffer *avbuf;
659
660
    /*
661
     * blocks until:
662
     *  1. encoded packet available
663
     *  2. an input buffer ready to be dequeued
664
     */
665
    avbuf = v4l2_dequeue_v4l2buf(ctx, -1);
666
    if (!avbuf) {
667
        if (ctx->done)
668
            return AVERROR_EOF;
669
670
        return AVERROR(EAGAIN);
671
    }
672
673
    return ff_v4l2_buffer_buf_to_avpkt(pkt, avbuf);
674
}
675
676
int ff_v4l2_context_get_format(V4L2Context* ctx, int probe)
677
{
678
    struct v4l2_format_update fmt = { 0 };
679
    int ret;
680
681
    if  (ctx->av_codec_id == AV_CODEC_ID_RAWVIDEO) {
682
        ret = v4l2_get_raw_format(ctx, &fmt.av_fmt);
683
        if (ret)
684
            return ret;
685
686
        fmt.update_avfmt = !probe;
687
        v4l2_save_to_context(ctx, &fmt);
688
689
        /* format has been tried already */
690
        return ret;
691
    }
692
693
    ret = v4l2_get_coded_format(ctx, &fmt.v4l2_fmt);
694
    if (ret)
695
        return ret;
696
697
    fmt.update_v4l2 = 1;
698
    v4l2_save_to_context(ctx, &fmt);
699
700
    return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_TRY_FMT, &ctx->format);
701
}
702
703
int ff_v4l2_context_set_format(V4L2Context* ctx)
704
{
705
    return ioctl(ctx_to_m2mctx(ctx)->fd, VIDIOC_S_FMT, &ctx->format);
706
}
707
708
void ff_v4l2_context_release(V4L2Context* ctx)
709
{
710
    int ret;
711
712
    if (!ctx->buffers)
713
        return;
714
715
    ret = v4l2_release_buffers(ctx);
716
    if (ret)
717
        av_log(logger(ctx), AV_LOG_WARNING, "V4L2 failed to unmap the %s buffers\n", ctx->name);
718
719
    av_freep(&ctx->buffers);
720
}
721
722
int ff_v4l2_context_init(V4L2Context* ctx)
723
{
724
    V4L2m2mContext *s = ctx_to_m2mctx(ctx);
725
    struct v4l2_requestbuffers req;
726
    int ret, i;
727
728
    if (!v4l2_type_supported(ctx)) {
729
        av_log(logger(ctx), AV_LOG_ERROR, "type %i not supported\n", ctx->type);
730
        return AVERROR_PATCHWELCOME;
731
    }
732
733
    ret = ioctl(s->fd, VIDIOC_G_FMT, &ctx->format);
734
    if (ret)
735
        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_G_FMT failed\n", ctx->name);
736
737
    memset(&req, 0, sizeof(req));
738
    req.count = ctx->num_buffers;
739
    req.memory = V4L2_MEMORY_MMAP;
740
    req.type = ctx->type;
741
    ret = ioctl(s->fd, VIDIOC_REQBUFS, &req);
742
    if (ret < 0) {
743
        av_log(logger(ctx), AV_LOG_ERROR, "%s VIDIOC_REQBUFS failed: %s\n", ctx->name, strerror(errno));
744
        return AVERROR(errno);
745
    }
746
747
    ctx->num_buffers = req.count;
748
    ctx->buffers = av_mallocz(ctx->num_buffers * sizeof(V4L2Buffer));
749
    if (!ctx->buffers) {
750
        av_log(logger(ctx), AV_LOG_ERROR, "%s malloc enomem\n", ctx->name);
751
        return AVERROR(ENOMEM);
752
    }
753
754
    for (i = 0; i < req.count; i++) {
755
        ctx->buffers[i].context = ctx;
756
        ret = ff_v4l2_buffer_initialize(&ctx->buffers[i], i);
757
        if (ret < 0) {
758
            av_log(logger(ctx), AV_LOG_ERROR, "%s buffer[%d] initialization (%s)\n", ctx->name, i, av_err2str(ret));
759
            goto error;
760
        }
761
    }
762
763
    av_log(logger(ctx), AV_LOG_DEBUG, "%s: %s %02d buffers initialized: %04ux%04u, sizeimage %08u, bytesperline %08u\n", ctx->name,
764
        V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? av_fourcc2str(ctx->format.fmt.pix_mp.pixelformat) : av_fourcc2str(ctx->format.fmt.pix.pixelformat),
765
        req.count,
766
        v4l2_get_width(&ctx->format),
767
        v4l2_get_height(&ctx->format),
768
        V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].sizeimage : ctx->format.fmt.pix.sizeimage,
769
        V4L2_TYPE_IS_MULTIPLANAR(ctx->type) ? ctx->format.fmt.pix_mp.plane_fmt[0].bytesperline : ctx->format.fmt.pix.bytesperline);
770
771
    return 0;
772
773
error:
774
    v4l2_release_buffers(ctx);
775
776
    av_freep(&ctx->buffers);
777
778
    return ret;
779
}