libavcodec/v4l2_m2m_dec.c - third_party/ffmpeg - Git at Google

 /*
  * V4L2 mem2mem decoders
  *
  * Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
  * Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */

 #include <linux/videodev2.h>
 #include <sys/ioctl.h>
 #include "libavutil/pixfmt.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/opt.h"
 #include "libavcodec/avcodec.h"
 #include "codec_internal.h"
 #include "libavcodec/decode.h"

 #include "v4l2_context.h"
 #include "v4l2_m2m.h"
 #include "v4l2_fmt.h"

 static int v4l2_try_start(AVCodecContext *avctx)
 {
     V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
     V4L2Context *const capture = &s->capture;
     V4L2Context *const output = &s->output;
     struct v4l2_selection selection = { 0 };
     int ret;

     /* 1. start the output process */
     if (!output->streamon) {
         ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
         if (ret < 0) {
             av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON on output context\n");
             return ret;
         }
     }

     if (capture->streamon)
         return 0;

     /* 2. get the capture format */
     capture->format.type = capture->type;
     ret = ioctl(s->fd, VIDIOC_G_FMT, &capture->format);
     if (ret) {
         av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_FMT ioctl\n");
         return ret;
     }

     /* 2.1 update the AVCodecContext */
     avctx->pix_fmt = ff_v4l2_format_v4l2_to_avfmt(capture->format.fmt.pix_mp.pixelformat, AV_CODEC_ID_RAWVIDEO);
     capture->av_pix_fmt = avctx->pix_fmt;

     /* 3. set the crop parameters */
     selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     selection.r.height = avctx->coded_height;
     selection.r.width = avctx->coded_width;
     ret = ioctl(s->fd, VIDIOC_S_SELECTION, &selection);
     if (!ret) {
         ret = ioctl(s->fd, VIDIOC_G_SELECTION, &selection);
         if (ret) {
             av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_SELECTION ioctl\n");
         } else {
             av_log(avctx, AV_LOG_DEBUG, "crop output %dx%d\n", selection.r.width, selection.r.height);
             /* update the size of the resulting frame */
             capture->height = selection.r.height;
             capture->width  = selection.r.width;
         }
     }

     /* 4. init the capture context now that we have the capture format */
     if (!capture->buffers) {
         ret = ff_v4l2_context_init(capture);
         if (ret) {
             av_log(avctx, AV_LOG_ERROR, "can't request capture buffers\n");
             return AVERROR(ENOMEM);
         }
     }

     /* 5. start the capture process */
     ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
     if (ret) {
         av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON, on capture context\n");
         return ret;
     }

     return 0;
 }

 static int v4l2_prepare_decoder(V4L2m2mContext *s)
 {
     struct v4l2_event_subscription sub;
     V4L2Context *output = &s->output;
     int ret;

     /**
      * requirements
      */
     memset(&sub, 0, sizeof(sub));
     sub.type = V4L2_EVENT_SOURCE_CHANGE;
     ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
     if ( ret < 0) {
         if (output->height == 0 || output->width == 0) {
             av_log(s->avctx, AV_LOG_ERROR,
                 "the v4l2 driver does not support VIDIOC_SUBSCRIBE_EVENT\n"
                 "you must provide codec_height and codec_width on input\n");
             return ret;
         }
     }

     memset(&sub, 0, sizeof(sub));
     sub.type = V4L2_EVENT_EOS;
     ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
     if (ret < 0)
         av_log(s->avctx, AV_LOG_WARNING,
                "the v4l2 driver does not support end of stream VIDIOC_SUBSCRIBE_EVENT\n");

     return 0;
 }

 static int v4l2_receive_frame(AVCodecContext *avctx, AVFrame *frame)
 {
     V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
     V4L2Context *const capture = &s->capture;
     V4L2Context *const output = &s->output;
     int ret;

     if (!s->buf_pkt.size) {
         ret = ff_decode_get_packet(avctx, &s->buf_pkt);
         if (ret < 0) {
             if (ret == AVERROR(EAGAIN))
                 return ff_v4l2_context_dequeue_frame(capture, frame, 0);
             else if (ret != AVERROR_EOF)
                 return ret;
         }
     }

     if (s->draining)
         goto dequeue;

     ret = ff_v4l2_context_enqueue_packet(output, &s->buf_pkt);
     if (ret < 0 && ret != AVERROR(EAGAIN))
         goto fail;

     /* if EAGAIN don't unref packet and try to enqueue in the next iteration */
     if (ret != AVERROR(EAGAIN))
         av_packet_unref(&s->buf_pkt);

     if (!s->draining) {
         ret = v4l2_try_start(avctx);
         if (ret) {
             /* cant recover */
             if (ret != AVERROR(ENOMEM))
                 ret = 0;
             goto fail;
         }
     }

 dequeue:
     return ff_v4l2_context_dequeue_frame(capture, frame, -1);
 fail:
     av_packet_unref(&s->buf_pkt);
     return ret;
 }

 static av_cold int v4l2_decode_init(AVCodecContext *avctx)
 {
     V4L2Context *capture, *output;
     V4L2m2mContext *s;
     V4L2m2mPriv *priv = avctx->priv_data;
     int ret;

     ret = ff_v4l2_m2m_create_context(priv, &s);
     if (ret < 0)
         return ret;

     capture = &s->capture;
     output = &s->output;

     /* if these dimensions are invalid (ie, 0 or too small) an event will be raised
      * by the v4l2 driver; this event will trigger a full pipeline reconfig and
      * the proper values will be retrieved from the kernel driver.
      */
     output->height = capture->height = avctx->coded_height;
     output->width = capture->width = avctx->coded_width;

     output->av_codec_id = avctx->codec_id;
     output->av_pix_fmt  = AV_PIX_FMT_NONE;

     capture->av_codec_id = AV_CODEC_ID_RAWVIDEO;
     capture->av_pix_fmt = avctx->pix_fmt;

     s->avctx = avctx;
     ret = ff_v4l2_m2m_codec_init(priv);
     if (ret) {
         av_log(avctx, AV_LOG_ERROR, "can't configure decoder\n");
         return ret;
     }

     return v4l2_prepare_decoder(s);
 }

 static av_cold int v4l2_decode_close(AVCodecContext *avctx)
 {
     return ff_v4l2_m2m_codec_end(avctx->priv_data);
 }

 #define OFFSET(x) offsetof(V4L2m2mPriv, x)
 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

 static const AVOption options[] = {
     V4L_M2M_DEFAULT_OPTS,
     { "num_capture_buffers", "Number of buffers in the capture context",
         OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 2, INT_MAX, FLAGS },
     { NULL},
 };

 #define M2MDEC_CLASS(NAME) \
     static const AVClass v4l2_m2m_ ## NAME ## _dec_class = { \
         .class_name = #NAME "_v4l2m2m_decoder", \
         .item_name  = av_default_item_name, \
         .option     = options, \
         .version    = LIBAVUTIL_VERSION_INT, \
     };

 #define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \
     M2MDEC_CLASS(NAME) \
     const FFCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
         .p.name         = #NAME "_v4l2m2m" , \
         CODEC_LONG_NAME("V4L2 mem2mem " LONGNAME " decoder wrapper"), \
         .p.type         = AVMEDIA_TYPE_VIDEO, \
         .p.id           = CODEC , \
         .priv_data_size = sizeof(V4L2m2mPriv), \
         .p.priv_class   = &v4l2_m2m_ ## NAME ## _dec_class, \
         .init           = v4l2_decode_init, \
         FF_CODEC_RECEIVE_FRAME_CB(v4l2_receive_frame), \
         .close          = v4l2_decode_close, \
         .bsfs           = bsf_name, \
         .p.capabilities = AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
         .caps_internal  = FF_CODEC_CAP_NOT_INIT_THREADSAFE | \
                           FF_CODEC_CAP_INIT_CLEANUP, \
         .p.wrapper_name = "v4l2m2m", \
     }

 M2MDEC(h264,  "H.264", AV_CODEC_ID_H264,       "h264_mp4toannexb");
 M2MDEC(hevc,  "HEVC",  AV_CODEC_ID_HEVC,       "hevc_mp4toannexb");
 M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);
 M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);
 M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4,      NULL);
 M2MDEC(h263,  "H.263", AV_CODEC_ID_H263,       NULL);
 M2MDEC(vc1 ,  "VC1",   AV_CODEC_ID_VC1,        NULL);
 M2MDEC(vp8,   "VP8",   AV_CODEC_ID_VP8,        NULL);
 M2MDEC(vp9,   "VP9",   AV_CODEC_ID_VP9,        NULL);
	/*
	* V4L2 mem2mem decoders
	*
	* Copyright (C) 2017 Alexis Ballier <aballier@gentoo.org>
	* Copyright (C) 2017 Jorge Ramirez <jorge.ramirez-ortiz@linaro.org>
	*
	* This file is part of FFmpeg.
	*
	* FFmpeg is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* FFmpeg is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with FFmpeg; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <linux/videodev2.h>
	#include <sys/ioctl.h>
	#include "libavutil/pixfmt.h"
	#include "libavutil/pixdesc.h"
	#include "libavutil/opt.h"
	#include "libavcodec/avcodec.h"
	#include "codec_internal.h"
	#include "libavcodec/decode.h"

	#include "v4l2_context.h"
	#include "v4l2_m2m.h"
	#include "v4l2_fmt.h"

	static int v4l2_try_start(AVCodecContext *avctx)
	{
	V4L2m2mContext s = ((V4L2m2mPriv)avctx->priv_data)->context;
	V4L2Context *const capture = &s->capture;
	V4L2Context *const output = &s->output;
	struct v4l2_selection selection = { 0 };
	int ret;

	/* 1. start the output process */
	if (!output->streamon) {
	ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
	if (ret < 0) {
	av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON on output context\n");
	return ret;
	}
	}

	if (capture->streamon)
	return 0;

	/* 2. get the capture format */
	capture->format.type = capture->type;
	ret = ioctl(s->fd, VIDIOC_G_FMT, &capture->format);
	if (ret) {
	av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_FMT ioctl\n");
	return ret;
	}

	/* 2.1 update the AVCodecContext */
	avctx->pix_fmt = ff_v4l2_format_v4l2_to_avfmt(capture->format.fmt.pix_mp.pixelformat, AV_CODEC_ID_RAWVIDEO);
	capture->av_pix_fmt = avctx->pix_fmt;

	/* 3. set the crop parameters */
	selection.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	selection.r.height = avctx->coded_height;
	selection.r.width = avctx->coded_width;
	ret = ioctl(s->fd, VIDIOC_S_SELECTION, &selection);
	if (!ret) {
	ret = ioctl(s->fd, VIDIOC_G_SELECTION, &selection);
	if (ret) {
	av_log(avctx, AV_LOG_WARNING, "VIDIOC_G_SELECTION ioctl\n");
	} else {
	av_log(avctx, AV_LOG_DEBUG, "crop output %dx%d\n", selection.r.width, selection.r.height);
	/* update the size of the resulting frame */
	capture->height = selection.r.height;
	capture->width = selection.r.width;
	}
	}

	/* 4. init the capture context now that we have the capture format */
	if (!capture->buffers) {
	ret = ff_v4l2_context_init(capture);
	if (ret) {
	av_log(avctx, AV_LOG_ERROR, "can't request capture buffers\n");
	return AVERROR(ENOMEM);
	}
	}

	/* 5. start the capture process */
	ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
	if (ret) {
	av_log(avctx, AV_LOG_DEBUG, "VIDIOC_STREAMON, on capture context\n");
	return ret;
	}

	return 0;
	}

	static int v4l2_prepare_decoder(V4L2m2mContext *s)
	{
	struct v4l2_event_subscription sub;
	V4L2Context *output = &s->output;
	int ret;

	/**
	* requirements
	*/
	memset(&sub, 0, sizeof(sub));
	sub.type = V4L2_EVENT_SOURCE_CHANGE;
	ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
	if ( ret < 0) {
	if (output->height == 0 \|\| output->width == 0) {
	av_log(s->avctx, AV_LOG_ERROR,
	"the v4l2 driver does not support VIDIOC_SUBSCRIBE_EVENT\n"
	"you must provide codec_height and codec_width on input\n");
	return ret;
	}
	}

	memset(&sub, 0, sizeof(sub));
	sub.type = V4L2_EVENT_EOS;
	ret = ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
	if (ret < 0)
	av_log(s->avctx, AV_LOG_WARNING,
	"the v4l2 driver does not support end of stream VIDIOC_SUBSCRIBE_EVENT\n");

	return 0;
	}

	static int v4l2_receive_frame(AVCodecContext avctx, AVFrame frame)
	{
	V4L2m2mContext s = ((V4L2m2mPriv)avctx->priv_data)->context;
	V4L2Context *const capture = &s->capture;
	V4L2Context *const output = &s->output;
	int ret;

	if (!s->buf_pkt.size) {
	ret = ff_decode_get_packet(avctx, &s->buf_pkt);
	if (ret < 0) {
	if (ret == AVERROR(EAGAIN))
	return ff_v4l2_context_dequeue_frame(capture, frame, 0);
	else if (ret != AVERROR_EOF)
	return ret;
	}
	}

	if (s->draining)
	goto dequeue;

	ret = ff_v4l2_context_enqueue_packet(output, &s->buf_pkt);
	if (ret < 0 && ret != AVERROR(EAGAIN))
	goto fail;

	/* if EAGAIN don't unref packet and try to enqueue in the next iteration */
	if (ret != AVERROR(EAGAIN))
	av_packet_unref(&s->buf_pkt);

	if (!s->draining) {
	ret = v4l2_try_start(avctx);
	if (ret) {
	/* cant recover */
	if (ret != AVERROR(ENOMEM))
	ret = 0;
	goto fail;
	}
	}

	dequeue:
	return ff_v4l2_context_dequeue_frame(capture, frame, -1);
	fail:
	av_packet_unref(&s->buf_pkt);
	return ret;
	}

	static av_cold int v4l2_decode_init(AVCodecContext *avctx)
	{
	V4L2Context capture, output;
	V4L2m2mContext *s;
	V4L2m2mPriv *priv = avctx->priv_data;
	int ret;

	ret = ff_v4l2_m2m_create_context(priv, &s);
	if (ret < 0)
	return ret;

	capture = &s->capture;
	output = &s->output;

	/* if these dimensions are invalid (ie, 0 or too small) an event will be raised
	* by the v4l2 driver; this event will trigger a full pipeline reconfig and
	* the proper values will be retrieved from the kernel driver.
	*/
	output->height = capture->height = avctx->coded_height;
	output->width = capture->width = avctx->coded_width;

	output->av_codec_id = avctx->codec_id;
	output->av_pix_fmt = AV_PIX_FMT_NONE;

	capture->av_codec_id = AV_CODEC_ID_RAWVIDEO;
	capture->av_pix_fmt = avctx->pix_fmt;

	s->avctx = avctx;
	ret = ff_v4l2_m2m_codec_init(priv);
	if (ret) {
	av_log(avctx, AV_LOG_ERROR, "can't configure decoder\n");
	return ret;
	}

	return v4l2_prepare_decoder(s);
	}

	static av_cold int v4l2_decode_close(AVCodecContext *avctx)
	{
	return ff_v4l2_m2m_codec_end(avctx->priv_data);
	}

	#define OFFSET(x) offsetof(V4L2m2mPriv, x)
	#define FLAGS AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_DECODING_PARAM

	static const AVOption options[] = {
	V4L_M2M_DEFAULT_OPTS,
	{ "num_capture_buffers", "Number of buffers in the capture context",
	OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 2, INT_MAX, FLAGS },
	{ NULL},
	};

	#define M2MDEC_CLASS(NAME) \
	static const AVClass v4l2_m2m_ ## NAME ## _dec_class = { \
	.class_name = #NAME "_v4l2m2m_decoder", \
	.item_name = av_default_item_name, \
	.option = options, \
	.version = LIBAVUTIL_VERSION_INT, \
	};

	#define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \
	M2MDEC_CLASS(NAME) \
	const FFCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
	.p.name = #NAME "_v4l2m2m" , \
	CODEC_LONG_NAME("V4L2 mem2mem " LONGNAME " decoder wrapper"), \
	.p.type = AVMEDIA_TYPE_VIDEO, \
	.p.id = CODEC , \
	.priv_data_size = sizeof(V4L2m2mPriv), \
	.p.priv_class = &v4l2_m2m_ ## NAME ## _dec_class, \
	.init = v4l2_decode_init, \
	FF_CODEC_RECEIVE_FRAME_CB(v4l2_receive_frame), \
	.close = v4l2_decode_close, \
	.bsfs = bsf_name, \
	.p.capabilities = AV_CODEC_CAP_HARDWARE \| AV_CODEC_CAP_DELAY \| AV_CODEC_CAP_AVOID_PROBING, \
	.caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE \| \
	FF_CODEC_CAP_INIT_CLEANUP, \
	.p.wrapper_name = "v4l2m2m", \
	}

	M2MDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb");
	M2MDEC(hevc, "HEVC", AV_CODEC_ID_HEVC, "hevc_mp4toannexb");
	M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);
	M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);
	M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4, NULL);
	M2MDEC(h263, "H.263", AV_CODEC_ID_H263, NULL);
	M2MDEC(vc1 , "VC1", AV_CODEC_ID_VC1, NULL);
	M2MDEC(vp8, "VP8", AV_CODEC_ID_VP8, NULL);
	M2MDEC(vp9, "VP9", AV_CODEC_ID_VP9, NULL);