]> git.sesse.net Git - ffmpeg/blob - libavcodec/v4l2_m2m_dec.c
avcodec/v4l2_context: use EAGAIN to signal when input buffers are unavailable
[ffmpeg] / libavcodec / v4l2_m2m_dec.c
1 /*
2  * V4L2 mem2mem decoders
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 "libavutil/pixfmt.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/opt.h"
29 #include "libavcodec/avcodec.h"
30 #include "libavcodec/decode.h"
31
32 #include "v4l2_context.h"
33 #include "v4l2_m2m.h"
34 #include "v4l2_fmt.h"
35
36 static int v4l2_try_start(AVCodecContext *avctx)
37 {
38     V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
39     V4L2Context *const capture = &s->capture;
40     V4L2Context *const output = &s->output;
41     struct v4l2_selection selection;
42     int ret;
43
44     /* 1. start the output process */
45     if (!output->streamon) {
46         ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
47         if (ret < 0) {
48             av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON on output context\n");
49             return ret;
50         }
51     }
52
53     if (capture->streamon)
54         return 0;
55
56     /* 2. get the capture format */
57     capture->format.type = capture->type;
58     ret = ioctl(s->fd, VIDIOC_G_FMT, &capture->format);
59     if (ret) {
60         av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_FMT ioctl\n");
61         return ret;
62     }
63
64     /* 2.1 update the AVCodecContext */
65     avctx->pix_fmt = ff_v4l2_format_v4l2_to_avfmt(capture->format.fmt.pix_mp.pixelformat, AV_CODEC_ID_RAWVIDEO);
66     capture->av_pix_fmt = avctx->pix_fmt;
67
68     /* 3. set the crop parameters */
69     selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
70     selection.r.height = avctx->coded_height;
71     selection.r.width = avctx->coded_width;
72     ret = ioctl(s->fd, VIDIOC_S_SELECTION, &selection);
73     if (!ret) {
74         ret = ioctl(s->fd, VIDIOC_G_SELECTION, &selection);
75         if (ret) {
76             av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_SELECTION ioctl\n");
77         } else {
78             av_log(avctx, AV_LOG_DEBUG, "crop output %dx%d\n", selection.r.width, selection.r.height);
79             /* update the size of the resulting frame */
80             capture->height = selection.r.height;
81             capture->width  = selection.r.width;
82         }
83     }
84
85     /* 4. init the capture context now that we have the capture format */
86     if (!capture->buffers) {
87         ret = ff_v4l2_context_init(capture);
88         if (ret) {
89             av_log(avctx, AV_LOG_ERROR, "can't request capture buffers\n");
90             return AVERROR(ENOMEM);
91         }
92     }
93
94     /* 5. start the capture process */
95     ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
96     if (ret) {
97         av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON, on capture context\n");
98         return ret;
99     }
100
101     return 0;
102 }
103
104 static int v4l2_prepare_decoder(V4L2m2mContext *s)
105 {
106     struct v4l2_event_subscription sub;
107     V4L2Context *output = &s->output;
108     int ret;
109
110     /**
111      * requirements
112      */
113     memset(&sub, 0, sizeof(sub));
114     sub.type = V4L2_EVENT_SOURCE_CHANGE;
115     ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
116     if ( ret < 0) {
117         if (output->height == 0 || output->width == 0) {
118             av_log(s->avctx, AV_LOG_ERROR,
119                 "the v4l2 driver does not support VIDIOC_SUBSCRIBE_EVENT\n"
120                 "you must provide codec_height and codec_width on input\n");
121             return ret;
122         }
123     }
124
125     return 0;
126 }
127
128 static int v4l2_receive_frame(AVCodecContext *avctx, AVFrame *frame)
129 {
130     V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
131     V4L2Context *const capture = &s->capture;
132     V4L2Context *const output = &s->output;
133     AVPacket avpkt = {0};
134     int ret;
135
136     ret = ff_decode_get_packet(avctx, &avpkt);
137     if (ret < 0 && ret != AVERROR_EOF)
138         return ret;
139
140     if (s->draining)
141         goto dequeue;
142
143     ret = ff_v4l2_context_enqueue_packet(output, &avpkt);
144     if (ret < 0) {
145         if (ret != AVERROR(EAGAIN))
146            return ret;
147         /* no input buffers available, continue dequeing */
148     }
149
150     if (avpkt.size) {
151         ret = v4l2_try_start(avctx);
152         if (ret) {
153             av_packet_unref(&avpkt);
154
155             /* cant recover */
156             if (ret == AVERROR(ENOMEM))
157                 return ret;
158
159             return 0;
160         }
161     }
162
163 dequeue:
164     av_packet_unref(&avpkt);
165     return ff_v4l2_context_dequeue_frame(capture, frame);
166 }
167
168 static av_cold int v4l2_decode_init(AVCodecContext *avctx)
169 {
170     V4L2Context *capture, *output;
171     V4L2m2mContext *s;
172     int ret;
173
174     ret = ff_v4l2_m2m_create_context(avctx, &s);
175     if (ret < 0)
176         return ret;
177
178     capture = &s->capture;
179     output = &s->output;
180
181     /* if these dimensions are invalid (ie, 0 or too small) an event will be raised
182      * by the v4l2 driver; this event will trigger a full pipeline reconfig and
183      * the proper values will be retrieved from the kernel driver.
184      */
185     output->height = capture->height = avctx->coded_height;
186     output->width = capture->width = avctx->coded_width;
187
188     output->av_codec_id = avctx->codec_id;
189     output->av_pix_fmt  = AV_PIX_FMT_NONE;
190
191     capture->av_codec_id = AV_CODEC_ID_RAWVIDEO;
192     capture->av_pix_fmt = avctx->pix_fmt;
193
194     ret = ff_v4l2_m2m_codec_init(avctx);
195     if (ret) {
196         V4L2m2mPriv *priv = avctx->priv_data;
197         av_log(avctx, AV_LOG_ERROR, "can't configure decoder\n");
198         s->self_ref = NULL;
199         av_buffer_unref(&priv->context_ref);
200
201         return ret;
202     }
203
204     return v4l2_prepare_decoder(s);
205 }
206
207 #define OFFSET(x) offsetof(V4L2m2mPriv, x)
208 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
209
210 static const AVOption options[] = {
211     V4L_M2M_DEFAULT_OPTS,
212     { "num_capture_buffers", "Number of buffers in the capture context",
213         OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 20, INT_MAX, FLAGS },
214     { NULL},
215 };
216
217 #define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \
218 static const AVClass v4l2_m2m_ ## NAME ## _dec_class = {\
219     .class_name = #NAME "_v4l2_m2m_decoder",\
220     .item_name  = av_default_item_name,\
221     .option     = options,\
222     .version    = LIBAVUTIL_VERSION_INT,\
223 };\
224 \
225 AVCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
226     .name           = #NAME "_v4l2m2m" ,\
227     .long_name      = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " decoder wrapper"),\
228     .type           = AVMEDIA_TYPE_VIDEO,\
229     .id             = CODEC ,\
230     .priv_data_size = sizeof(V4L2m2mPriv),\
231     .priv_class     = &v4l2_m2m_ ## NAME ## _dec_class,\
232     .init           = v4l2_decode_init,\
233     .receive_frame  = v4l2_receive_frame,\
234     .close          = ff_v4l2_m2m_codec_end,\
235     .bsfs           = bsf_name, \
236     .capabilities   = AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_DELAY | \
237                       AV_CODEC_CAP_AVOID_PROBING, \
238     .wrapper_name   = "v4l2m2m", \
239 };
240
241 M2MDEC(h264,  "H.264", AV_CODEC_ID_H264,       "h264_mp4toannexb");
242 M2MDEC(hevc,  "HEVC",  AV_CODEC_ID_HEVC,       "hevc_mp4toannexb");
243 M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);
244 M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);
245 M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4,      NULL);
246 M2MDEC(h263,  "H.263", AV_CODEC_ID_H263,       NULL);
247 M2MDEC(vc1 ,  "VC1",   AV_CODEC_ID_VC1,        NULL);
248 M2MDEC(vp8,   "VP8",   AV_CODEC_ID_VP8,        NULL);
249 M2MDEC(vp9,   "VP9",   AV_CODEC_ID_VP9,        NULL);