FFmpeg: libavcodec/v4l2_m2m_dec.c Source File

FFmpeg

[フレーム]

libavcodec

v4l2_m2m_dec.c

Go to the documentation of this file.

1 /*

2 * V4L2 mem2mem decoders

3 *

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 */

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"

33 #include "v4l2_context.h"

34 #include "v4l2_m2m.h"

35 #include "v4l2_fmt.h"

37 static 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;

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 }

54 if (capture->streamon)

55 return 0;

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 }

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;

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 }

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 }

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

105 static 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

136 static 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 /* can't recover */

168 if (ret != AVERROR(ENOMEM))

169 ret = 0;

170 goto fail;

171 }

172 }

173

174 dequeue:

175 return ff_v4l2_context_dequeue_frame(capture, frame, -1);

176 fail:

177 av_packet_unref(&s->buf_pkt);

178 return ret;

179 }

180

181 static 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

218 static 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

226 static 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}, 2, 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 CODEC_LONG_NAME("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_NOT_INIT_THREADSAFE | \

256 FF_CODEC_CAP_INIT_CLEANUP, \

257 .p.wrapper_name = "v4l2m2m", \

258 }

259

260 M2MDEC(h264, "H.264", AV_CODEC_ID_H264, "h264_mp4toannexb");

261 M2MDEC(hevc, "HEVC", AV_CODEC_ID_HEVC, "hevc_mp4toannexb");

262 M2MDEC(mpeg1, "MPEG1", AV_CODEC_ID_MPEG1VIDEO, NULL);

263 M2MDEC(mpeg2, "MPEG2", AV_CODEC_ID_MPEG2VIDEO, NULL);

264 M2MDEC(mpeg4, "MPEG4", AV_CODEC_ID_MPEG4, NULL);

265 M2MDEC(h263, "H.263", AV_CODEC_ID_H263, NULL);

266 M2MDEC(vc1 , "VC1", AV_CODEC_ID_VC1, NULL);

267 M2MDEC(vp8, "VP8", AV_CODEC_ID_VP8, NULL);

268 M2MDEC(vp9, "VP9", AV_CODEC_ID_VP9, NULL);

ff_v4l2_context_init

int ff_v4l2_context_init(V4L2Context *ctx)

Initializes a V4L2Context.

Definition: v4l2_context.c:713

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: packet.c:433

ff_decode_get_packet

int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)

Called by decoders to get the next packet for decoding.

Definition: decode.c:245

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

V4L2Context::av_pix_fmt

enum AVPixelFormat av_pix_fmt

AVPixelFormat corresponding to this buffer context.

Definition: v4l2_context.h:54

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

v4l2_decode_close

static av_cold int v4l2_decode_close(AVCodecContext *avctx)

Definition: v4l2_m2m_dec.c:218

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

output

filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output

Definition: filter_design.txt:226

V4L2Context::av_codec_id

enum AVCodecID av_codec_id

AVCodecID corresponding to this buffer context.

Definition: v4l2_context.h:60

V4L2m2mContext

Definition: v4l2_m2m.h:43

AV_CODEC_ID_RAWVIDEO

@ AV_CODEC_ID_RAWVIDEO

Definition: codec_id.h:65

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

pixdesc.h

AVOption

AVOption.

Definition: opt.h:429

fail

#define fail()

Definition: checkasm.h:206

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:607

V4L2Context::streamon

int streamon

Whether the stream has been started (VIDIOC_STREAMON has been sent).

Definition: v4l2_context.h:88

OFFSET

#define OFFSET(x)

Definition: v4l2_m2m_dec.c:223

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

ff_v4l2_m2m_codec_init

av_cold int ff_v4l2_m2m_codec_init(V4L2m2mPriv *priv)

Probes the video nodes looking for the required codec capabilities.

Definition: v4l2_m2m.c:290

v4l2_fmt.h

#define s(width, name)

Definition: cbs_vp9.c:198

ff_v4l2_format_v4l2_to_avfmt

enum AVPixelFormat ff_v4l2_format_v4l2_to_avfmt(uint32_t v4l2_fmt, enum AVCodecID avcodec)

Definition: v4l2_fmt.c:132

AV_CODEC_ID_VP9

@ AV_CODEC_ID_VP9

Definition: codec_id.h:222

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

decode.h

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:441

V4L2Context

Definition: v4l2_context.h:37

NULL

#define NULL

Definition: coverity.c:32

V4L2Context::type

enum v4l2_buf_type type

Type of this buffer context.

Definition: v4l2_context.h:48

ff_v4l2_context_enqueue_packet

int ff_v4l2_context_enqueue_packet(V4L2Context *ctx, const AVPacket *pkt)

Enqueues a buffer to a V4L2Context from an AVPacket.

Definition: v4l2_context.c:602

ff_v4l2_m2m_create_context

int ff_v4l2_m2m_create_context(V4L2m2mPriv *priv, V4L2m2mContext **s)

Allocate a new context and references for a V4L2 M2M instance.

Definition: v4l2_m2m.c:328

V4L_M2M_DEFAULT_OPTS

#define V4L_M2M_DEFAULT_OPTS

Definition: v4l2_m2m.h:39

options

Definition: swscale.c:43

AV_CODEC_ID_MPEG1VIDEO

@ AV_CODEC_ID_MPEG1VIDEO

Definition: codec_id.h:53

M2MDEC

#define M2MDEC(NAME, LONGNAME, CODEC, bsf_name)

Definition: v4l2_m2m_dec.c:241

v4l2_decode_init

static av_cold int v4l2_decode_init(AVCodecContext *avctx)

Definition: v4l2_m2m_dec.c:181

V4L2Context::width

int width

Width and height of the frames it produces (in case of a capture context, e.g.

Definition: v4l2_context.h:72

codec_internal.h

FLAGS

#define FLAGS

Definition: v4l2_m2m_dec.c:224

AV_CODEC_ID_H263

@ AV_CODEC_ID_H263

Definition: codec_id.h:56

ff_v4l2_context_dequeue_frame

int ff_v4l2_context_dequeue_frame(V4L2Context *ctx, AVFrame *frame, int timeout)

Dequeues a buffer from a V4L2Context to an AVFrame.

Definition: v4l2_context.c:627

ff_v4l2_context_set_status

int ff_v4l2_context_set_status(V4L2Context *ctx, uint32_t cmd)

Sets the status of a V4L2Context.

Definition: v4l2_context.c:563

V4L2Context::buffers

V4L2Buffer * buffers

Indexed array of V4L2Buffers.

Definition: v4l2_context.h:78

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:228

AV_CODEC_ID_VC1

@ AV_CODEC_ID_VC1

Definition: codec_id.h:122

v4l2_context.h

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

avcodec.h

ret

Definition: filter_design.txt:187

pixfmt.h

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

v4l2_receive_frame

static int v4l2_receive_frame(AVCodecContext *avctx, AVFrame *frame)

Definition: v4l2_m2m_dec.c:136

V4L2Context::height

int height

Definition: v4l2_context.h:72

AVCodecContext

main external API structure.

Definition: avcodec.h:431

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE