You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

353 lines
11KB

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