]> git.sesse.net Git - ffmpeg/blob - libavcodec/v4l2_m2m_enc.c
avcodec/v4l2_m2m_enc: reindent code
[ffmpeg] / libavcodec / v4l2_m2m_enc.c
1 /*
2  * V4L2 mem2mem encoders
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 <search.h>
27 #include "libavcodec/avcodec.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/pixfmt.h"
30 #include "libavutil/opt.h"
31 #include "v4l2_context.h"
32 #include "v4l2_m2m.h"
33 #include "v4l2_fmt.h"
34
35 #define MPEG_CID(x) V4L2_CID_MPEG_VIDEO_##x
36 #define MPEG_VIDEO(x) V4L2_MPEG_VIDEO_##x
37
38 static inline void v4l2_set_timeperframe(V4L2m2mContext *s, unsigned int num, unsigned int den)
39 {
40     struct v4l2_streamparm parm = { 0 };
41
42     parm.type = V4L2_TYPE_IS_MULTIPLANAR(s->output.type) ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : V4L2_BUF_TYPE_VIDEO_OUTPUT;
43     parm.parm.output.timeperframe.denominator = den;
44     parm.parm.output.timeperframe.numerator = num;
45
46     if (ioctl(s->fd, VIDIOC_S_PARM, &parm) < 0)
47         av_log(s->avctx, AV_LOG_WARNING, "Failed to set timeperframe");
48 }
49
50 static inline void v4l2_set_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int value, const char *name, int log_warning)
51 {
52     struct v4l2_ext_controls ctrls = { { 0 } };
53     struct v4l2_ext_control ctrl = { 0 };
54
55     /* set ctrls */
56     ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
57     ctrls.controls = &ctrl;
58     ctrls.count = 1;
59
60     /* set ctrl*/
61     ctrl.value = value;
62     ctrl.id = id;
63
64     if (ioctl(s->fd, VIDIOC_S_EXT_CTRLS, &ctrls) < 0)
65         av_log(s->avctx, log_warning || errno != EINVAL ? AV_LOG_WARNING : AV_LOG_DEBUG,
66                "Failed to set %s: %s\n", name, strerror(errno));
67     else
68         av_log(s->avctx, AV_LOG_DEBUG, "Encoder: %s = %d\n", name, value);
69 }
70
71 static inline int v4l2_get_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int *value, const char *name, int log_warning)
72 {
73     struct v4l2_ext_controls ctrls = { { 0 } };
74     struct v4l2_ext_control ctrl = { 0 };
75     int ret;
76
77     /* set ctrls */
78     ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
79     ctrls.controls = &ctrl;
80     ctrls.count = 1;
81
82     /* set ctrl*/
83     ctrl.id = id ;
84
85     ret = ioctl(s->fd, VIDIOC_G_EXT_CTRLS, &ctrls);
86     if (ret < 0) {
87         av_log(s->avctx, log_warning || errno != EINVAL ? AV_LOG_WARNING : AV_LOG_DEBUG,
88                "Failed to get %s\n", name);
89         return ret;
90     }
91
92     *value = ctrl.value;
93
94     return 0;
95 }
96
97 static inline unsigned int v4l2_h264_profile_from_ff(int p)
98 {
99     static const struct h264_profile  {
100         unsigned int ffmpeg_val;
101         unsigned int v4l2_val;
102     } profile[] = {
103         { FF_PROFILE_H264_CONSTRAINED_BASELINE, MPEG_VIDEO(H264_PROFILE_CONSTRAINED_BASELINE) },
104         { FF_PROFILE_H264_HIGH_444_PREDICTIVE, MPEG_VIDEO(H264_PROFILE_HIGH_444_PREDICTIVE) },
105         { FF_PROFILE_H264_HIGH_422_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_422_INTRA) },
106         { FF_PROFILE_H264_HIGH_444_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_444_INTRA) },
107         { FF_PROFILE_H264_HIGH_10_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_10_INTRA) },
108         { FF_PROFILE_H264_HIGH_422, MPEG_VIDEO(H264_PROFILE_HIGH_422) },
109         { FF_PROFILE_H264_BASELINE, MPEG_VIDEO(H264_PROFILE_BASELINE) },
110         { FF_PROFILE_H264_EXTENDED, MPEG_VIDEO(H264_PROFILE_EXTENDED) },
111         { FF_PROFILE_H264_HIGH_10, MPEG_VIDEO(H264_PROFILE_HIGH_10) },
112         { FF_PROFILE_H264_MAIN, MPEG_VIDEO(H264_PROFILE_MAIN) },
113         { FF_PROFILE_H264_HIGH, MPEG_VIDEO(H264_PROFILE_HIGH) },
114     };
115     int i;
116
117     for (i = 0; i < FF_ARRAY_ELEMS(profile); i++) {
118         if (profile[i].ffmpeg_val == p)
119             return profile[i].v4l2_val;
120     }
121     return AVERROR(ENOENT);
122 }
123
124 static inline int v4l2_mpeg4_profile_from_ff(int p)
125 {
126     static const struct mpeg4_profile {
127         unsigned int ffmpeg_val;
128         unsigned int v4l2_val;
129     } profile[] = {
130         { FF_PROFILE_MPEG4_ADVANCED_CODING, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY) },
131         { FF_PROFILE_MPEG4_ADVANCED_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_SIMPLE) },
132         { FF_PROFILE_MPEG4_SIMPLE_SCALABLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE_SCALABLE) },
133         { FF_PROFILE_MPEG4_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE) },
134         { FF_PROFILE_MPEG4_CORE, MPEG_VIDEO(MPEG4_PROFILE_CORE) },
135     };
136     int i;
137
138     for (i = 0; i < FF_ARRAY_ELEMS(profile); i++) {
139         if (profile[i].ffmpeg_val == p)
140             return profile[i].v4l2_val;
141     }
142     return AVERROR(ENOENT);
143 }
144
145 static int v4l2_check_b_frame_support(V4L2m2mContext *s)
146 {
147     if (s->avctx->max_b_frames)
148         av_log(s->avctx, AV_LOG_WARNING, "Encoder does not support b-frames yet\n");
149
150     v4l2_set_ext_ctrl(s, MPEG_CID(B_FRAMES), 0, "number of B-frames", 0);
151     v4l2_get_ext_ctrl(s, MPEG_CID(B_FRAMES), &s->avctx->max_b_frames, "number of B-frames", 0);
152     if (s->avctx->max_b_frames == 0)
153         return 0;
154
155     avpriv_report_missing_feature(s->avctx, "DTS/PTS calculation for V4L2 encoding");
156
157     return AVERROR_PATCHWELCOME;
158 }
159
160 static inline void v4l2_subscribe_eos_event(V4L2m2mContext *s)
161 {
162     struct v4l2_event_subscription sub;
163
164     memset(&sub, 0, sizeof(sub));
165     sub.type = V4L2_EVENT_EOS;
166     if (ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub) < 0)
167         av_log(s->avctx, AV_LOG_WARNING,
168                "the v4l2 driver does not support end of stream VIDIOC_SUBSCRIBE_EVENT\n");
169 }
170
171 static int v4l2_prepare_encoder(V4L2m2mContext *s)
172 {
173     AVCodecContext *avctx = s->avctx;
174     int qmin_cid, qmax_cid, qmin, qmax;
175     int ret, val;
176
177     /**
178      * requirements
179      */
180     v4l2_subscribe_eos_event(s);
181
182     ret = v4l2_check_b_frame_support(s);
183     if (ret)
184         return ret;
185
186     /**
187      * settingss
188      */
189     if (avctx->framerate.num || avctx->framerate.den)
190         v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
191
192     /* set ext ctrls */
193     v4l2_set_ext_ctrl(s, MPEG_CID(HEADER_MODE), MPEG_VIDEO(HEADER_MODE_SEPARATE), "header mode", 0);
194     v4l2_set_ext_ctrl(s, MPEG_CID(BITRATE) , avctx->bit_rate, "bit rate", 1);
195     v4l2_set_ext_ctrl(s, MPEG_CID(FRAME_RC_ENABLE), 1, "frame level rate control", 0);
196     v4l2_set_ext_ctrl(s, MPEG_CID(GOP_SIZE), avctx->gop_size,"gop size", 1);
197
198     av_log(avctx, AV_LOG_DEBUG,
199         "Encoder Context: id (%d), profile (%d), frame rate(%d/%d), number b-frames (%d), "
200         "gop size (%d), bit rate (%"PRId64"), qmin (%d), qmax (%d)\n",
201         avctx->codec_id, avctx->profile, avctx->framerate.num, avctx->framerate.den,
202         avctx->max_b_frames, avctx->gop_size, avctx->bit_rate, avctx->qmin, avctx->qmax);
203
204     switch (avctx->codec_id) {
205     case AV_CODEC_ID_H264:
206         if (avctx->profile != FF_PROFILE_UNKNOWN) {
207             val = v4l2_h264_profile_from_ff(avctx->profile);
208             if (val < 0)
209                 av_log(avctx, AV_LOG_WARNING, "h264 profile not found\n");
210             else
211                 v4l2_set_ext_ctrl(s, MPEG_CID(H264_PROFILE), val, "h264 profile", 1);
212         }
213         qmin_cid = MPEG_CID(H264_MIN_QP);
214         qmax_cid = MPEG_CID(H264_MAX_QP);
215         qmin = 0;
216         qmax = 51;
217         break;
218     case AV_CODEC_ID_MPEG4:
219         if (avctx->profile != FF_PROFILE_UNKNOWN) {
220             val = v4l2_mpeg4_profile_from_ff(avctx->profile);
221             if (val < 0)
222                 av_log(avctx, AV_LOG_WARNING, "mpeg4 profile not found\n");
223             else
224                 v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_PROFILE), val, "mpeg4 profile", 1);
225         }
226         qmin_cid = MPEG_CID(MPEG4_MIN_QP);
227         qmax_cid = MPEG_CID(MPEG4_MAX_QP);
228         if (avctx->flags & AV_CODEC_FLAG_QPEL)
229             v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_QPEL), 1, "qpel", 1);
230         qmin = 1;
231         qmax = 31;
232         break;
233     case AV_CODEC_ID_H263:
234         qmin_cid = MPEG_CID(H263_MIN_QP);
235         qmax_cid = MPEG_CID(H263_MAX_QP);
236         qmin = 1;
237         qmax = 31;
238         break;
239     case AV_CODEC_ID_VP8:
240         qmin_cid = MPEG_CID(VPX_MIN_QP);
241         qmax_cid = MPEG_CID(VPX_MAX_QP);
242         qmin = 0;
243         qmax = 127;
244         break;
245     case AV_CODEC_ID_VP9:
246         qmin_cid = MPEG_CID(VPX_MIN_QP);
247         qmax_cid = MPEG_CID(VPX_MAX_QP);
248         qmin = 0;
249         qmax = 255;
250         break;
251     default:
252         return 0;
253     }
254
255     if (qmin != avctx->qmin || qmax != avctx->qmax)
256         av_log(avctx, AV_LOG_WARNING, "Encoder adjusted: qmin (%d), qmax (%d)\n", qmin, qmax);
257
258     v4l2_set_ext_ctrl(s, qmin_cid, qmin, "minimum video quantizer scale", 0);
259     v4l2_set_ext_ctrl(s, qmax_cid, qmax, "maximum video quantizer scale", 0);
260
261     return 0;
262 }
263
264 static int v4l2_send_frame(AVCodecContext *avctx, const AVFrame *frame)
265 {
266     V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
267     V4L2Context *const output = &s->output;
268
269 #ifdef V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME
270     if (frame && frame->pict_type == AV_PICTURE_TYPE_I)
271         v4l2_set_ext_ctrl(s, MPEG_CID(FORCE_KEY_FRAME), 0, "force key frame", 1);
272 #endif
273
274     return ff_v4l2_context_enqueue_frame(output, frame);
275 }
276
277 static int v4l2_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
278 {
279     V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
280     V4L2Context *const capture = &s->capture;
281     V4L2Context *const output = &s->output;
282     int ret;
283
284     if (s->draining)
285         goto dequeue;
286
287     if (!output->streamon) {
288         ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
289         if (ret) {
290             av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMON failed on output context\n");
291             return ret;
292         }
293     }
294
295     if (!capture->streamon) {
296         ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
297         if (ret) {
298             av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMON failed on capture context\n");
299             return ret;
300         }
301     }
302
303 dequeue:
304     return ff_v4l2_context_dequeue_packet(capture, avpkt);
305 }
306
307 static av_cold int v4l2_encode_init(AVCodecContext *avctx)
308 {
309     V4L2Context *capture, *output;
310     V4L2m2mContext *s;
311     V4L2m2mPriv *priv = avctx->priv_data;
312     enum AVPixelFormat pix_fmt_output;
313     uint32_t v4l2_fmt_output;
314     int ret;
315
316     ret = ff_v4l2_m2m_create_context(priv, &s);
317     if (ret < 0)
318         return ret;
319
320     capture = &s->capture;
321     output  = &s->output;
322
323     /* common settings output/capture */
324     output->height = capture->height = avctx->height;
325     output->width = capture->width = avctx->width;
326
327     /* output context */
328     output->av_codec_id = AV_CODEC_ID_RAWVIDEO;
329     output->av_pix_fmt = avctx->pix_fmt;
330
331     /* capture context */
332     capture->av_codec_id = avctx->codec_id;
333     capture->av_pix_fmt = AV_PIX_FMT_NONE;
334
335     s->avctx = avctx;
336     ret = ff_v4l2_m2m_codec_init(priv);
337     if (ret) {
338         av_log(avctx, AV_LOG_ERROR, "can't configure encoder\n");
339         return ret;
340     }
341
342     if (V4L2_TYPE_IS_MULTIPLANAR(output->type))
343         v4l2_fmt_output = output->format.fmt.pix_mp.pixelformat;
344     else
345         v4l2_fmt_output = output->format.fmt.pix.pixelformat;
346
347     pix_fmt_output = ff_v4l2_format_v4l2_to_avfmt(v4l2_fmt_output, AV_CODEC_ID_RAWVIDEO);
348     if (pix_fmt_output != avctx->pix_fmt) {
349         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt_output);
350         av_log(avctx, AV_LOG_ERROR, "Encoder requires %s pixel format.\n", desc->name);
351         return AVERROR(EINVAL);
352     }
353
354     return v4l2_prepare_encoder(s);
355 }
356
357 static av_cold int v4l2_encode_close(AVCodecContext *avctx)
358 {
359     return ff_v4l2_m2m_codec_end(avctx->priv_data);
360 }
361
362 #define OFFSET(x) offsetof(V4L2m2mPriv, x)
363 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
364
365 static const AVOption options[] = {
366     V4L_M2M_DEFAULT_OPTS,
367     { "num_capture_buffers", "Number of buffers in the capture context",
368         OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 4 }, 4, INT_MAX, FLAGS },
369     { NULL },
370 };
371
372 #define M2MENC_CLASS(NAME) \
373     static const AVClass v4l2_m2m_ ## NAME ## _enc_class = { \
374         .class_name = #NAME "_v4l2m2m_encoder", \
375         .item_name  = av_default_item_name, \
376         .option     = options, \
377         .version    = LIBAVUTIL_VERSION_INT, \
378     };
379
380 #define M2MENC(NAME, LONGNAME, CODEC) \
381     M2MENC_CLASS(NAME) \
382     AVCodec ff_ ## NAME ## _v4l2m2m_encoder = { \
383         .name           = #NAME "_v4l2m2m" , \
384         .long_name      = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " encoder wrapper"), \
385         .type           = AVMEDIA_TYPE_VIDEO, \
386         .id             = CODEC , \
387         .priv_data_size = sizeof(V4L2m2mPriv), \
388         .priv_class     = &v4l2_m2m_ ## NAME ##_enc_class, \
389         .init           = v4l2_encode_init, \
390         .send_frame     = v4l2_send_frame, \
391         .receive_packet = v4l2_receive_packet, \
392         .close          = v4l2_encode_close, \
393         .capabilities   = AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_DELAY, \
394         .wrapper_name   = "v4l2m2m", \
395     };
396
397 M2MENC(mpeg4,"MPEG4", AV_CODEC_ID_MPEG4);
398 M2MENC(h263, "H.263", AV_CODEC_ID_H263);
399 M2MENC(h264, "H.264", AV_CODEC_ID_H264);
400 M2MENC(hevc, "HEVC",  AV_CODEC_ID_HEVC);
401 M2MENC(vp8,  "VP8",   AV_CODEC_ID_VP8);