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