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