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 "codec_internal.h"
31#include "libavcodec/decode.h"
32
33#include "v4l2_context.h"
34#include "v4l2_m2m.h"
35#include "v4l2_fmt.h"
36
37static 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
105static 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
136static 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) {
146            if (ret == AVERROR(EAGAIN))
147                return ff_v4l2_context_dequeue_frame(capture, frame, 0);
148            else if (ret != AVERROR_EOF)
149                return ret;
150        }
151    }
152
153    if (s->draining)
154        goto dequeue;
155
156    ret = ff_v4l2_context_enqueue_packet(output, &s->buf_pkt);
157    if (ret < 0 && ret != AVERROR(EAGAIN))
158        goto fail;
159
160    /* if EAGAIN don't unref packet and try to enqueue in the next iteration */
161    if (ret != AVERROR(EAGAIN))
162        av_packet_unref(&s->buf_pkt);
163
164    if (!s->draining) {
165        ret = v4l2_try_start(avctx);
166        if (ret) {
167            /* cant recover */
168            if (ret != AVERROR(ENOMEM))
169                ret = 0;
170            goto fail;
171        }
172    }
173
174dequeue:
175    return ff_v4l2_context_dequeue_frame(capture, frame, -1);
176fail:
177    av_packet_unref(&s->buf_pkt);
178    return ret;
179}
180
181static av_cold int v4l2_decode_init(AVCodecContext *avctx)
182{
183    V4L2Context *capture, *output;
184    V4L2m2mContext *s;
185    V4L2m2mPriv *priv = avctx->priv_data;
186    int ret;
187
188    ret = ff_v4l2_m2m_create_context(priv, &s);
189    if (ret < 0)
190        return ret;
191
192    capture = &s->capture;
193    output = &s->output;
194
195    /* if these dimensions are invalid (ie, 0 or too small) an event will be raised
196     * by the v4l2 driver; this event will trigger a full pipeline reconfig and
197     * the proper values will be retrieved from the kernel driver.
198     */
199    output->height = capture->height = avctx->coded_height;
200    output->width = capture->width = avctx->coded_width;
201
202    output->av_codec_id = avctx->codec_id;
203    output->av_pix_fmt  = AV_PIX_FMT_NONE;
204
205    capture->av_codec_id = AV_CODEC_ID_RAWVIDEO;
206    capture->av_pix_fmt = avctx->pix_fmt;
207
208    s->avctx = avctx;
209    ret = ff_v4l2_m2m_codec_init(priv);
210    if (ret) {
211        av_log(avctx, AV_LOG_ERROR, "can't configure decoder\n");
212        return ret;
213    }
214
215    return v4l2_prepare_decoder(s);
216}
217
218static av_cold int v4l2_decode_close(AVCodecContext *avctx)
219{
220    return ff_v4l2_m2m_codec_end(avctx->priv_data);
221}
222
223#define OFFSET(x) offsetof(V4L2m2mPriv, x)
224#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
225
226static const AVOption options[] = {
227    V4L_M2M_DEFAULT_OPTS,
228    { "num_capture_buffers", "Number of buffers in the capture context",
229        OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 20}, 20, INT_MAX, FLAGS },
230    { NULL},
231};
232
233#define M2MDEC_CLASS(NAME) \
234    static const AVClass v4l2_m2m_ ## NAME ## _dec_class = { \
235        .class_name = #NAME "_v4l2m2m_decoder", \
236        .item_name  = av_default_item_name, \
237        .option     = options, \
238        .version    = LIBAVUTIL_VERSION_INT, \
239    };
240
241#define M2MDEC(NAME, LONGNAME, CODEC, bsf_name) \
242    M2MDEC_CLASS(NAME) \
243    const FFCodec ff_ ## NAME ## _v4l2m2m_decoder = { \
244        .p.name         = #NAME "_v4l2m2m" , \
245        .p.long_name    = NULL_IF_CONFIG_SMALL("V4L2 mem2mem " LONGNAME " decoder wrapper"), \
246        .p.type         = AVMEDIA_TYPE_VIDEO, \
247        .p.id           = CODEC , \
248        .priv_data_size = sizeof(V4L2m2mPriv), \
249        .p.priv_class   = &v4l2_m2m_ ## NAME ## _dec_class, \
250        .init           = v4l2_decode_init, \
251        FF_CODEC_RECEIVE_FRAME_CB(v4l2_receive_frame), \
252        .close          = v4l2_decode_close, \
253        .bsfs           = bsf_name, \
254        .p.capabilities = AV_CODEC_CAP_HARDWARE | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
255        .caps_internal  = FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_INIT_CLEANUP, \
256        .p.wrapper_name = "v4l2m2m", \
257    }
258
259M2MDEC(h264,  "H.264", AV_CODEC_ID_H264,       "h264_mp4toannexb");
260M2MDEC(hevc,  "HEVC",  AV_CODEC_ID_HEVC,       "hevc_mp4toannexb");
261M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);
262M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);
263M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4,      NULL);
264M2MDEC(h263,  "H.263", AV_CODEC_ID_H263,       NULL);
265M2MDEC(vc1 ,  "VC1",   AV_CODEC_ID_VC1,        NULL);
266M2MDEC(vp8,   "VP8",   AV_CODEC_ID_VP8,        NULL);
267M2MDEC(vp9,   "VP9",   AV_CODEC_ID_VP9,        NULL);
268