FFmpeg: libavdevice/v4l2.c Source File

FFmpeg

[フレーム]

libavdevice

v4l2.c

Go to the documentation of this file.

1 /*

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * Video4Linux2 grab interface

25 *

26 * Part of this file is based on the V4L2 video capture example

27 * (http://linuxtv.org/downloads/v4l-dvb-apis/capture-example.html)

28 *

29 * Thanks to Michael Niedermayer for providing the mapping between

30 * V4L2_PIX_FMT_* and AV_PIX_FMT_*

31 */

33 #include "v4l2-common.h"

34 #include <dirent.h>

36 #if CONFIG_LIBV4L2

37 #include <libv4l2.h>

38 #endif

40 static const int desired_video_buffers = 256;

42 #define V4L_ALLFORMATS 3

43 #define V4L_RAWFORMATS 1

44 #define V4L_COMPFORMATS 2

46 /**

47 * Return timestamps to the user exactly as returned by the kernel

48 */

49 #define V4L_TS_DEFAULT 0

50 /**

51 * Autodetect the kind of timestamps returned by the kernel and convert to

52 * absolute (wall clock) timestamps.

53 */

54 #define V4L_TS_ABS 1

55 /**

56 * Assume kernel timestamps are from the monotonic clock and convert to

57 * absolute timestamps.

58 */

59 #define V4L_TS_MONO2ABS 2

61 /**

62 * Once the kind of timestamps returned by the kernel have been detected,

63 * the value of the timefilter (NULL or not) determines whether a conversion

64 * takes place.

65 */

66 #define V4L_TS_CONVERT_READY V4L_TS_DEFAULT

68 struct video_data {

69 AVClass *class;

70 int fd;

71 int pixelformat; /* V4L2_PIX_FMT_* */

72 int width, height;

73 int frame_size;

74 int interlaced;

75 int top_field_first;

76 int ts_mode;

77 TimeFilter *timefilter;

78 int64_t last_time_m;

80 int buffers;

81 volatile int buffers_queued;

82 void **buf_start;

83 unsigned int *buf_len;

84 char *standard;

85 v4l2_std_id std_id;

86 int channel;

87 char *pixel_format; /**< Set by a private option. */

88 int list_format; /**< Set by a private option. */

89 int list_standard; /**< Set by a private option. */

90 char *framerate; /**< Set by a private option. */

92 int use_libv4l2;

93 int (*open_f)(const char *file, int oflag, ...);

94 int (*close_f)(int fd);

95 int (*dup_f)(int fd);

96 int (*ioctl_f)(int fd, unsigned long int request, ...);

97 ssize_t (*read_f)(int fd, void *buffer, size_t n);

98 void *(*mmap_f)(void *start, size_t length, int prot, int flags, int fd, int64_t offset);

99 int (*munmap_f)(void *_start, size_t length);

100 };

101

102 struct buff_data {

103 struct video_data *s;

104 int index;

105 };

106

107 static int device_open(AVFormatContext *ctx)

108 {

109 struct video_data *s = ctx->priv_data;

110 struct v4l2_capability cap;

111 int fd;

112 int err;

113 int flags = O_RDWR;

114

115 #define SET_WRAPPERS(prefix) do { \

116 s->open_f = prefix ## open; \

117 s->close_f = prefix ## close; \

118 s->dup_f = prefix ## dup; \

119 s->ioctl_f = prefix ## ioctl; \

120 s->read_f = prefix ## read; \

121 s->mmap_f = prefix ## mmap; \

122 s->munmap_f = prefix ## munmap; \

123 } while (0)

124

125 if (s->use_libv4l2) {

126 #if CONFIG_LIBV4L2

127 SET_WRAPPERS(v4l2_);

128 #else

129 av_log(ctx, AV_LOG_ERROR, "libavdevice is not build with libv4l2 support.\n");

130 return AVERROR(EINVAL);

131 #endif

132 } else {

133 SET_WRAPPERS();

134 }

135

136 #define v4l2_open s->open_f

137 #define v4l2_close s->close_f

138 #define v4l2_dup s->dup_f

139 #define v4l2_ioctl s->ioctl_f

140 #define v4l2_read s->read_f

141 #define v4l2_mmap s->mmap_f

142 #define v4l2_munmap s->munmap_f

143

144 if (ctx->flags & AVFMT_FLAG_NONBLOCK) {

145 flags |= O_NONBLOCK;

146 }

147

148 fd = v4l2_open(ctx->filename, flags, 0);

149 if (fd < 0) {

150 err = AVERROR(errno);

151 av_log(ctx, AV_LOG_ERROR, "Cannot open video device %s: %s\n",

152 ctx->filename, av_err2str(err));

153 return err;

154 }

155

156 if (v4l2_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0) {

157 err = AVERROR(errno);

158 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n",

159 av_err2str(err));

160 goto fail;

161 }

162

163 av_log(ctx, AV_LOG_VERBOSE, "fd:%d capabilities:%x\n",

164 fd, cap.capabilities);

165

166 if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {

167 av_log(ctx, AV_LOG_ERROR, "Not a video capture device.\n");

168 err = AVERROR(ENODEV);

169 goto fail;

170 }

171

172 if (!(cap.capabilities & V4L2_CAP_STREAMING)) {

173 av_log(ctx, AV_LOG_ERROR,

174 "The device does not support the streaming I/O method.\n");

175 err = AVERROR(ENOSYS);

176 goto fail;

177 }

178

179 return fd;

180

181 fail:

182 v4l2_close(fd);

183 return err;

184 }

185

186 static int device_init(AVFormatContext *ctx, int *width, int *height,

187 uint32_t pixelformat)

188 {

189 struct video_data *s = ctx->priv_data;

190 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };

191 int res = 0;

192

193 fmt.fmt.pix.width = *width;

194 fmt.fmt.pix.height = *height;

195 fmt.fmt.pix.pixelformat = pixelformat;

196 fmt.fmt.pix.field = V4L2_FIELD_ANY;

197

198 /* Some drivers will fail and return EINVAL when the pixelformat

199 is not supported (even if type field is valid and supported) */

200 if (v4l2_ioctl(s->fd, VIDIOC_S_FMT, &fmt) < 0)

201 res = AVERROR(errno);

202

203 if ((*width != fmt.fmt.pix.width) || (*height != fmt.fmt.pix.height)) {

204 av_log(ctx, AV_LOG_INFO,

205 "The V4L2 driver changed the video from %dx%d to %dx%d\n",

206 *width, *height, fmt.fmt.pix.width, fmt.fmt.pix.height);

207 *width = fmt.fmt.pix.width;

208 *height = fmt.fmt.pix.height;

209 }

210

211 if (pixelformat != fmt.fmt.pix.pixelformat) {

212 av_log(ctx, AV_LOG_DEBUG,

213 "The V4L2 driver changed the pixel format "

214 "from 0x%08X to 0x%08X\n",

215 pixelformat, fmt.fmt.pix.pixelformat);

216 res = AVERROR(EINVAL);

217 }

218

219 if (fmt.fmt.pix.field == V4L2_FIELD_INTERLACED) {

220 av_log(ctx, AV_LOG_DEBUG,

221 "The V4L2 driver is using the interlaced mode\n");

222 s->interlaced = 1;

223 }

224

225 return res;

226 }

227

228 static int first_field(const struct video_data *s)

229 {

230 int res;

231 v4l2_std_id std;

232

233 res = v4l2_ioctl(s->fd, VIDIOC_G_STD, &std);

234 if (res < 0)

235 return 0;

236 if (std & V4L2_STD_NTSC)

237 return 0;

238

239 return 1;

240 }

241

242 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE

243 static void list_framesizes(AVFormatContext *ctx, uint32_t pixelformat)

244 {

245 const struct video_data *s = ctx->priv_data;

246 struct v4l2_frmsizeenum vfse = { .pixel_format = pixelformat };

247

248 while(!v4l2_ioctl(s->fd, VIDIOC_ENUM_FRAMESIZES, &vfse)) {

249 switch (vfse.type) {

250 case V4L2_FRMSIZE_TYPE_DISCRETE:

251 av_log(ctx, AV_LOG_INFO, " %ux%u",

252 vfse.discrete.width, vfse.discrete.height);

253 break;

254 case V4L2_FRMSIZE_TYPE_CONTINUOUS:

255 case V4L2_FRMSIZE_TYPE_STEPWISE:

256 av_log(ctx, AV_LOG_INFO, " {%u-%u, %u}x{%u-%u, %u}",

257 vfse.stepwise.min_width,

258 vfse.stepwise.max_width,

259 vfse.stepwise.step_width,

260 vfse.stepwise.min_height,

261 vfse.stepwise.max_height,

262 vfse.stepwise.step_height);

263 }

264 vfse.index++;

265 }

266 }

267 #endif

268

269 static void list_formats(AVFormatContext *ctx, int type)

270 {

271 const struct video_data *s = ctx->priv_data;

272 struct v4l2_fmtdesc vfd = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };

273

274 while(!v4l2_ioctl(s->fd, VIDIOC_ENUM_FMT, &vfd)) {

275 enum AVCodecID codec_id = ff_fmt_v4l2codec(vfd.pixelformat);

276 enum AVPixelFormat pix_fmt = ff_fmt_v4l2ff(vfd.pixelformat, codec_id);

277

278 vfd.index++;

279

280 if (!(vfd.flags & V4L2_FMT_FLAG_COMPRESSED) &&

281 type & V4L_RAWFORMATS) {

282 const char *fmt_name = av_get_pix_fmt_name(pix_fmt);

283 av_log(ctx, AV_LOG_INFO, "Raw : %9s : %20s :",

284 fmt_name ? fmt_name : "Unsupported",

285 vfd.description);

286 } else if (vfd.flags & V4L2_FMT_FLAG_COMPRESSED &&

287 type & V4L_COMPFORMATS) {

288 const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);

289 av_log(ctx, AV_LOG_INFO, "Compressedll : %9s : %20s :",

290 desc ? desc->name : "Unsupported",

291 vfd.description);

292 } else {

293 continue;

294 }

295

296 #ifdef V4L2_FMT_FLAG_EMULATED

297 if (vfd.flags & V4L2_FMT_FLAG_EMULATED)

298 av_log(ctx, AV_LOG_INFO, " Emulated :");

299 #endif

300 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE

301 list_framesizes(ctx, vfd.pixelformat);

302 #endif

303 av_log(ctx, AV_LOG_INFO, "\n");

304 }

305 }

306

307 static void list_standards(AVFormatContext *ctx)

308 {

309 int ret;

310 struct video_data *s = ctx->priv_data;

311 struct v4l2_standard standard;

312

313 if (s->std_id == 0)

314 return;

315

316 for (standard.index = 0; ; standard.index++) {

317 if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {

318 ret = AVERROR(errno);

319 if (ret == AVERROR(EINVAL)) {

320 break;

321 } else {

322 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));

323 return;

324 }

325 }

326 av_log(ctx, AV_LOG_INFO, "%2d, %16"PRIx64", %s\n",

327 standard.index, (uint64_t)standard.id, standard.name);

328 }

329 }

330

331 static int mmap_init(AVFormatContext *ctx)

332 {

333 int i, res;

334 struct video_data *s = ctx->priv_data;

335 struct v4l2_requestbuffers req = {

336 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

337 .count = desired_video_buffers,

338 .memory = V4L2_MEMORY_MMAP

339 };

340

341 if (v4l2_ioctl(s->fd, VIDIOC_REQBUFS, &req) < 0) {

342 res = AVERROR(errno);

343 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_REQBUFS): %s\n", av_err2str(res));

344 return res;

345 }

346

347 if (req.count < 2) {

348 av_log(ctx, AV_LOG_ERROR, "Insufficient buffer memory\n");

349 return AVERROR(ENOMEM);

350 }

351 s->buffers = req.count;

352 s->buf_start = av_malloc_array(s->buffers, sizeof(void *));

353 if (!s->buf_start) {

354 av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer pointers\n");

355 return AVERROR(ENOMEM);

356 }

357 s->buf_len = av_malloc_array(s->buffers, sizeof(unsigned int));

358 if (!s->buf_len) {

359 av_log(ctx, AV_LOG_ERROR, "Cannot allocate buffer sizes\n");

360 av_freep(&s->buf_start);

361 return AVERROR(ENOMEM);

362 }

363

364 for (i = 0; i < req.count; i++) {

365 struct v4l2_buffer buf = {

366 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

367 .index = i,

368 .memory = V4L2_MEMORY_MMAP

369 };

370 if (v4l2_ioctl(s->fd, VIDIOC_QUERYBUF, &buf) < 0) {

371 res = AVERROR(errno);

372 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYBUF): %s\n", av_err2str(res));

373 return res;

374 }

375

376 s->buf_len[i] = buf.length;

377 if (s->frame_size > 0 && s->buf_len[i] < s->frame_size) {

378 av_log(ctx, AV_LOG_ERROR,

379 "buf_len[%d] = %d < expected frame size %d\n",

380 i, s->buf_len[i], s->frame_size);

381 return AVERROR(ENOMEM);

382 }

383 s->buf_start[i] = v4l2_mmap(NULL, buf.length,

384 PROT_READ | PROT_WRITE, MAP_SHARED,

385 s->fd, buf.m.offset);

386

387 if (s->buf_start[i] == MAP_FAILED) {

388 res = AVERROR(errno);

389 av_log(ctx, AV_LOG_ERROR, "mmap: %s\n", av_err2str(res));

390 return res;

391 }

392 }

393

394 return 0;

395 }

396

397 #if FF_API_DESTRUCT_PACKET

398 static void dummy_release_buffer(AVPacket *pkt)

399 {

400 av_assert0(0);

401 }

402 #endif

403

404 static int enqueue_buffer(struct video_data *s, struct v4l2_buffer *buf)

405 {

406 int res = 0;

407

408 if (v4l2_ioctl(s->fd, VIDIOC_QBUF, buf) < 0) {

409 res = AVERROR(errno);

410 av_log(NULL, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n", av_err2str(res));

411 } else {

412 avpriv_atomic_int_add_and_fetch(&s->buffers_queued, 1);

413 }

414

415 return res;

416 }

417

418 static void mmap_release_buffer(void *opaque, uint8_t *data)

419 {

420 struct v4l2_buffer buf = { 0 };

421 struct buff_data *buf_descriptor = opaque;

422 struct video_data *s = buf_descriptor->s;

423

424 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

425 buf.memory = V4L2_MEMORY_MMAP;

426 buf.index = buf_descriptor->index;

427 av_free(buf_descriptor);

428

429 enqueue_buffer(s, &buf);

430 }

431

432 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)

433 static int64_t av_gettime_monotonic(void)

434 {

435 return av_gettime_relative();

436 }

437 #endif

438

439 static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts)

440 {

441 struct video_data *s = ctx->priv_data;

442 int64_t now;

443

444 now = av_gettime();

445 if (s->ts_mode == V4L_TS_ABS &&

446 ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE) {

447 av_log(ctx, AV_LOG_INFO, "Detected absolute timestamps\n");

448 s->ts_mode = V4L_TS_CONVERT_READY;

449 return 0;

450 }

451 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)

452 if (ctx->streams[0]->avg_frame_rate.num) {

453 now = av_gettime_monotonic();

454 if (s->ts_mode == V4L_TS_MONO2ABS ||

455 (ts <= now + 1 * AV_TIME_BASE && ts >= now - 10 * AV_TIME_BASE)) {

456 AVRational tb = {AV_TIME_BASE, 1};

457 int64_t period = av_rescale_q(1, tb, ctx->streams[0]->avg_frame_rate);

458 av_log(ctx, AV_LOG_INFO, "Detected monotonic timestamps, converting\n");

459 /* microseconds instead of seconds, MHz instead of Hz */

460 s->timefilter = ff_timefilter_new(1, period, 1.0E-6);

461 if (!s->timefilter)

462 return AVERROR(ENOMEM);

463 s->ts_mode = V4L_TS_CONVERT_READY;

464 return 0;

465 }

466 }

467 #endif

468 av_log(ctx, AV_LOG_ERROR, "Unknown timestamps\n");

469 return AVERROR(EIO);

470 }

471

472 static int convert_timestamp(AVFormatContext *ctx, int64_t *ts)

473 {

474 struct video_data *s = ctx->priv_data;

475

476 if (s->ts_mode) {

477 int r = init_convert_timestamp(ctx, *ts);

478 if (r < 0)

479 return r;

480 }

481 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)

482 if (s->timefilter) {

483 int64_t nowa = av_gettime();

484 int64_t nowm = av_gettime_monotonic();

485 ff_timefilter_update(s->timefilter, nowa, nowm - s->last_time_m);

486 s->last_time_m = nowm;

487 *ts = ff_timefilter_eval(s->timefilter, *ts - nowm);

488 }

489 #endif

490 return 0;

491 }

492

493 static int mmap_read_frame(AVFormatContext *ctx, AVPacket *pkt)

494 {

495 struct video_data *s = ctx->priv_data;

496 struct v4l2_buffer buf = {

497 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

498 .memory = V4L2_MEMORY_MMAP

499 };

500 int res;

501

502 /* FIXME: Some special treatment might be needed in case of loss of signal... */

503 while ((res = v4l2_ioctl(s->fd, VIDIOC_DQBUF, &buf)) < 0 && (errno == EINTR));

504 if (res < 0) {

505 if (errno == EAGAIN) {

506 pkt->size = 0;

507 return AVERROR(EAGAIN);

508 }

509 res = AVERROR(errno);

510 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_DQBUF): %s\n",

511 av_err2str(res));

512 return res;

513 }

514

515 if (buf.index >= s->buffers) {

516 av_log(ctx, AV_LOG_ERROR, "Invalid buffer index received.\n");

517 return AVERROR(EINVAL);

518 }

519 avpriv_atomic_int_add_and_fetch(&s->buffers_queued, -1);

520 // always keep at least one buffer queued

521 av_assert0(avpriv_atomic_int_get(&s->buffers_queued) >= 1);

522

523 /* CPIA is a compressed format and we don't know the exact number of bytes

524 * used by a frame, so set it here as the driver announces it.

525 */

526 if (ctx->video_codec_id == AV_CODEC_ID_CPIA)

527 s->frame_size = buf.bytesused;

528

529 if (s->frame_size > 0 && buf.bytesused != s->frame_size) {

530 av_log(ctx, AV_LOG_ERROR,

531 "The v4l2 frame is %d bytes, but %d bytes are expected\n",

532 buf.bytesused, s->frame_size);

533 enqueue_buffer(s, &buf);

534 return AVERROR_INVALIDDATA;

535 }

536

537 /* Image is at s->buff_start[buf.index] */

538 if (avpriv_atomic_int_get(&s->buffers_queued) == FFMAX(s->buffers / 8, 1)) {

539 /* when we start getting low on queued buffers, fall back on copying data */

540 res = av_new_packet(pkt, buf.bytesused);

541 if (res < 0) {

542 av_log(ctx, AV_LOG_ERROR, "Error allocating a packet.\n");

543 enqueue_buffer(s, &buf);

544 return res;

545 }

546 memcpy(pkt->data, s->buf_start[buf.index], buf.bytesused);

547

548 res = enqueue_buffer(s, &buf);

549 if (res) {

550 av_free_packet(pkt);

551 return res;

552 }

553 } else {

554 struct buff_data *buf_descriptor;

555

556 pkt->data = s->buf_start[buf.index];

557 pkt->size = buf.bytesused;

558 #if FF_API_DESTRUCT_PACKET

559 FF_DISABLE_DEPRECATION_WARNINGS

560 pkt->destruct = dummy_release_buffer;

561 FF_ENABLE_DEPRECATION_WARNINGS

562 #endif

563

564 buf_descriptor = av_malloc(sizeof(struct buff_data));

565 if (!buf_descriptor) {

566 /* Something went wrong... Since av_malloc() failed, we cannot even

567 * allocate a buffer for memcpying into it

568 */

569 av_log(ctx, AV_LOG_ERROR, "Failed to allocate a buffer descriptor\n");

570 enqueue_buffer(s, &buf);

571

572 return AVERROR(ENOMEM);

573 }

574 buf_descriptor->index = buf.index;

575 buf_descriptor->s = s;

576

577 pkt->buf = av_buffer_create(pkt->data, pkt->size, mmap_release_buffer,

578 buf_descriptor, 0);

579 if (!pkt->buf) {

580 av_log(ctx, AV_LOG_ERROR, "Failed to create a buffer\n");

581 enqueue_buffer(s, &buf);

582 av_freep(&buf_descriptor);

583 return AVERROR(ENOMEM);

584 }

585 }

586 pkt->pts = buf.timestamp.tv_sec * INT64_C(1000000) + buf.timestamp.tv_usec;

587 convert_timestamp(ctx, &pkt->pts);

588

589 return s->buf_len[buf.index];

590 }

591

592 static int mmap_start(AVFormatContext *ctx)

593 {

594 struct video_data *s = ctx->priv_data;

595 enum v4l2_buf_type type;

596 int i, res;

597

598 for (i = 0; i < s->buffers; i++) {

599 struct v4l2_buffer buf = {

600 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

601 .index = i,

602 .memory = V4L2_MEMORY_MMAP

603 };

604

605 if (v4l2_ioctl(s->fd, VIDIOC_QBUF, &buf) < 0) {

606 res = AVERROR(errno);

607 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QBUF): %s\n",

608 av_err2str(res));

609 return res;

610 }

611 }

612 s->buffers_queued = s->buffers;

613

614 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

615 if (v4l2_ioctl(s->fd, VIDIOC_STREAMON, &type) < 0) {

616 res = AVERROR(errno);

617 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_STREAMON): %s\n",

618 av_err2str(res));

619 return res;

620 }

621

622 return 0;

623 }

624

625 static void mmap_close(struct video_data *s)

626 {

627 enum v4l2_buf_type type;

628 int i;

629

630 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

631 /* We do not check for the result, because we could

632 * not do anything about it anyway...

633 */

634 v4l2_ioctl(s->fd, VIDIOC_STREAMOFF, &type);

635 for (i = 0; i < s->buffers; i++) {

636 v4l2_munmap(s->buf_start[i], s->buf_len[i]);

637 }

638 av_freep(&s->buf_start);

639 av_freep(&s->buf_len);

640 }

641

642 static int v4l2_set_parameters(AVFormatContext *ctx)

643 {

644 struct video_data *s = ctx->priv_data;

645 struct v4l2_standard standard = { 0 };

646 struct v4l2_streamparm streamparm = { 0 };

647 struct v4l2_fract *tpf;

648 AVRational framerate_q = { 0 };

649 int i, ret;

650

651 if (s->framerate &&

652 (ret = av_parse_video_rate(&framerate_q, s->framerate)) < 0) {

653 av_log(ctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n",

654 s->framerate);

655 return ret;

656 }

657

658 if (s->standard) {

659 if (s->std_id) {

660 ret = 0;

661 av_log(ctx, AV_LOG_DEBUG, "Setting standard: %s\n", s->standard);

662 /* set tv standard */

663 for (i = 0; ; i++) {

664 standard.index = i;

665 if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {

666 ret = AVERROR(errno);

667 break;

668 }

669 if (!av_strcasecmp(standard.name, s->standard))

670 break;

671 }

672 if (ret < 0) {

673 av_log(ctx, AV_LOG_ERROR, "Unknown or unsupported standard '%s'\n", s->standard);

674 return ret;

675 }

676

677 if (v4l2_ioctl(s->fd, VIDIOC_S_STD, &standard.id) < 0) {

678 ret = AVERROR(errno);

679 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_STD): %s\n", av_err2str(ret));

680 return ret;

681 }

682 } else {

683 av_log(ctx, AV_LOG_WARNING,

684 "This device does not support any standard\n");

685 }

686 }

687

688 /* get standard */

689 if (v4l2_ioctl(s->fd, VIDIOC_G_STD, &s->std_id) == 0) {

690 tpf = &standard.frameperiod;

691 for (i = 0; ; i++) {

692 standard.index = i;

693 if (v4l2_ioctl(s->fd, VIDIOC_ENUMSTD, &standard) < 0) {

694 ret = AVERROR(errno);

695 if (ret == AVERROR(EINVAL)

696 #ifdef ENODATA

697 || ret == AVERROR(ENODATA)

698 #endif

699 ) {

700 tpf = &streamparm.parm.capture.timeperframe;

701 break;

702 }

703 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMSTD): %s\n", av_err2str(ret));

704 return ret;

705 }

706 if (standard.id == s->std_id) {

707 av_log(ctx, AV_LOG_DEBUG,

708 "Current standard: %s, id: %"PRIx64", frameperiod: %d/%d\n",

709 standard.name, (uint64_t)standard.id, tpf->numerator, tpf->denominator);

710 break;

711 }

712 }

713 } else {

714 tpf = &streamparm.parm.capture.timeperframe;

715 }

716

717 streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

718 if (v4l2_ioctl(s->fd, VIDIOC_G_PARM, &streamparm) < 0) {

719 ret = AVERROR(errno);

720 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_PARM): %s\n", av_err2str(ret));

721 return ret;

722 }

723

724 if (framerate_q.num && framerate_q.den) {

725 if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {

726 tpf = &streamparm.parm.capture.timeperframe;

727

728 av_log(ctx, AV_LOG_DEBUG, "Setting time per frame to %d/%d\n",

729 framerate_q.den, framerate_q.num);

730 tpf->numerator = framerate_q.den;

731 tpf->denominator = framerate_q.num;

732

733 if (v4l2_ioctl(s->fd, VIDIOC_S_PARM, &streamparm) < 0) {

734 ret = AVERROR(errno);

735 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_PARM): %s\n",

736 av_err2str(ret));

737 return ret;

738 }

739

740 if (framerate_q.num != tpf->denominator ||

741 framerate_q.den != tpf->numerator) {

742 av_log(ctx, AV_LOG_INFO,

743 "The driver changed the time per frame from "

744 "%d/%d to %d/%d\n",

745 framerate_q.den, framerate_q.num,

746 tpf->numerator, tpf->denominator);

747 }

748 } else {

749 av_log(ctx, AV_LOG_WARNING,

750 "The driver does not permit changing the time per frame\n");

751 }

752 }

753 if (tpf->denominator > 0 && tpf->numerator > 0) {

754 ctx->streams[0]->avg_frame_rate.num = tpf->denominator;

755 ctx->streams[0]->avg_frame_rate.den = tpf->numerator;

756 ctx->streams[0]->r_frame_rate = ctx->streams[0]->avg_frame_rate;

757 } else

758 av_log(ctx, AV_LOG_WARNING, "Time per frame unknown\n");

759

760 return 0;

761 }

762

763 static int device_try_init(AVFormatContext *ctx,

764 enum AVPixelFormat pix_fmt,

765 int *width,

766 int *height,

767 uint32_t *desired_format,

768 enum AVCodecID *codec_id)

769 {

770 int ret, i;

771

772 *desired_format = ff_fmt_ff2v4l(pix_fmt, ctx->video_codec_id);

773

774 if (*desired_format) {

775 ret = device_init(ctx, width, height, *desired_format);

776 if (ret < 0) {

777 *desired_format = 0;

778 if (ret != AVERROR(EINVAL))

779 return ret;

780 }

781 }

782

783 if (!*desired_format) {

784 for (i = 0; ff_fmt_conversion_table[i].codec_id != AV_CODEC_ID_NONE; i++) {

785 if (ctx->video_codec_id == AV_CODEC_ID_NONE ||

786 ff_fmt_conversion_table[i].codec_id == ctx->video_codec_id) {

787 av_log(ctx, AV_LOG_DEBUG, "Trying to set codec:%s pix_fmt:%s\n",

788 avcodec_get_name(ff_fmt_conversion_table[i].codec_id),

789 (char *)av_x_if_null(av_get_pix_fmt_name(ff_fmt_conversion_table[i].ff_fmt), "none"));

790

791 *desired_format = ff_fmt_conversion_table[i].v4l2_fmt;

792 ret = device_init(ctx, width, height, *desired_format);

793 if (ret >= 0)

794 break;

795 else if (ret != AVERROR(EINVAL))

796 return ret;

797 *desired_format = 0;

798 }

799 }

800

801 if (*desired_format == 0) {

802 av_log(ctx, AV_LOG_ERROR, "Cannot find a proper format for "

803 "codec '%s' (id %d), pixel format '%s' (id %d)\n",

804 avcodec_get_name(ctx->video_codec_id), ctx->video_codec_id,

805 (char *)av_x_if_null(av_get_pix_fmt_name(pix_fmt), "none"), pix_fmt);

806 ret = AVERROR(EINVAL);

807 }

808 }

809

810 *codec_id = ff_fmt_v4l2codec(*desired_format);

811 av_assert0(*codec_id != AV_CODEC_ID_NONE);

812 return ret;

813 }

814

815 static int v4l2_read_probe(AVProbeData *p)

816 {

817 if (av_strstart(p->filename, "/dev/video", NULL))

818 return AVPROBE_SCORE_MAX - 1;

819 return 0;

820 }

821

822 static int v4l2_read_header(AVFormatContext *ctx)

823 {

824 struct video_data *s = ctx->priv_data;

825 AVStream *st;

826 int res = 0;

827 uint32_t desired_format;

828 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

829 enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;

830 struct v4l2_input input = { 0 };

831

832 st = avformat_new_stream(ctx, NULL);

833 if (!st)

834 return AVERROR(ENOMEM);

835

836 #if CONFIG_LIBV4L2

837 /* silence libv4l2 logging. if fopen() fails v4l2_log_file will be NULL

838 and errors will get sent to stderr */

839 if (s->use_libv4l2)

840 v4l2_log_file = fopen("/dev/null", "w");

841 #endif

842

843 s->fd = device_open(ctx);

844 if (s->fd < 0)

845 return s->fd;

846

847 if (s->channel != -1) {

848 /* set video input */

849 av_log(ctx, AV_LOG_DEBUG, "Selecting input_channel: %d\n", s->channel);

850 if (v4l2_ioctl(s->fd, VIDIOC_S_INPUT, &s->channel) < 0) {

851 res = AVERROR(errno);

852 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_INPUT): %s\n", av_err2str(res));

853 goto fail;

854 }

855 } else {

856 /* get current video input */

857 if (v4l2_ioctl(s->fd, VIDIOC_G_INPUT, &s->channel) < 0) {

858 res = AVERROR(errno);

859 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_INPUT): %s\n", av_err2str(res));

860 goto fail;

861 }

862 }

863

864 /* enum input */

865 input.index = s->channel;

866 if (v4l2_ioctl(s->fd, VIDIOC_ENUMINPUT, &input) < 0) {

867 res = AVERROR(errno);

868 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_ENUMINPUT): %s\n", av_err2str(res));

869 goto fail;

870 }

871 s->std_id = input.std;

872 av_log(ctx, AV_LOG_DEBUG, "Current input_channel: %d, input_name: %s, input_std: %"PRIx64"\n",

873 s->channel, input.name, (uint64_t)input.std);

874

875 if (s->list_format) {

876 list_formats(ctx, s->list_format);

877 res = AVERROR_EXIT;

878 goto fail;

879 }

880

881 if (s->list_standard) {

882 list_standards(ctx);

883 res = AVERROR_EXIT;

884 goto fail;

885 }

886

887 avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */

888

889 if (s->pixel_format) {

890 AVCodec *codec = avcodec_find_decoder_by_name(s->pixel_format);

891

892 if (codec)

893 ctx->video_codec_id = codec->id;

894

895 pix_fmt = av_get_pix_fmt(s->pixel_format);

896

897 if (pix_fmt == AV_PIX_FMT_NONE && !codec) {

898 av_log(ctx, AV_LOG_ERROR, "No such input format: %s.\n",

899 s->pixel_format);

900

901 res = AVERROR(EINVAL);

902 goto fail;

903 }

904 }

905

906 if (!s->width && !s->height) {

907 struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE };

908

909 av_log(ctx, AV_LOG_VERBOSE,

910 "Querying the device for the current frame size\n");

911 if (v4l2_ioctl(s->fd, VIDIOC_G_FMT, &fmt) < 0) {

912 res = AVERROR(errno);

913 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_FMT): %s\n",

914 av_err2str(res));

915 goto fail;

916 }

917

918 s->width = fmt.fmt.pix.width;

919 s->height = fmt.fmt.pix.height;

920 av_log(ctx, AV_LOG_VERBOSE,

921 "Setting frame size to %dx%d\n", s->width, s->height);

922 }

923

924 res = device_try_init(ctx, pix_fmt, &s->width, &s->height, &desired_format, &codec_id);

925 if (res < 0)

926 goto fail;

927

928 /* If no pixel_format was specified, the codec_id was not known up

929 * until now. Set video_codec_id in the context, as codec_id will

930 * not be available outside this function

931 */

932 if (codec_id != AV_CODEC_ID_NONE && ctx->video_codec_id == AV_CODEC_ID_NONE)

933 ctx->video_codec_id = codec_id;

934

935 if ((res = av_image_check_size(s->width, s->height, 0, ctx)) < 0)

936 goto fail;

937

938 s->pixelformat = desired_format;

939

940 if ((res = v4l2_set_parameters(ctx)) < 0)

941 goto fail;

942

943 st->codec->pix_fmt = ff_fmt_v4l2ff(desired_format, codec_id);

944 s->frame_size =

945 avpicture_get_size(st->codec->pix_fmt, s->width, s->height);

946

947 if ((res = mmap_init(ctx)) ||

948 (res = mmap_start(ctx)) < 0)

949 goto fail;

950

951 s->top_field_first = first_field(s);

952

953 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

954 st->codec->codec_id = codec_id;

955 if (codec_id == AV_CODEC_ID_RAWVIDEO)

956 st->codec->codec_tag =

957 avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);

958 else if (codec_id == AV_CODEC_ID_H264) {

959 st->need_parsing = AVSTREAM_PARSE_HEADERS;

960 }

961 if (desired_format == V4L2_PIX_FMT_YVU420)

962 st->codec->codec_tag = MKTAG('Y', 'V', '1', '2');

963 else if (desired_format == V4L2_PIX_FMT_YVU410)

964 st->codec->codec_tag = MKTAG('Y', 'V', 'U', '9');

965 st->codec->width = s->width;

966 st->codec->height = s->height;

967 if (st->avg_frame_rate.den)

968 st->codec->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8;

969

970 return 0;

971

972 fail:

973 v4l2_close(s->fd);

974 return res;

975 }

976

977 static int v4l2_read_packet(AVFormatContext *ctx, AVPacket *pkt)

978 {

979 struct video_data *s = ctx->priv_data;

980 AVFrame *frame = ctx->streams[0]->codec->coded_frame;

981 int res;

982

983 av_init_packet(pkt);

984 if ((res = mmap_read_frame(ctx, pkt)) < 0) {

985 return res;

986 }

987

988 if (frame && s->interlaced) {

989 frame->interlaced_frame = 1;

990 frame->top_field_first = s->top_field_first;

991 }

992

993 return pkt->size;

994 }

995

996 static int v4l2_read_close(AVFormatContext *ctx)

997 {

998 struct video_data *s = ctx->priv_data;

999

1000 if (avpriv_atomic_int_get(&s->buffers_queued) != s->buffers)

1001 av_log(ctx, AV_LOG_WARNING, "Some buffers are still owned by the caller on "

1002 "close.\n");

1003

1004 mmap_close(s);

1005

1006 v4l2_close(s->fd);

1007 return 0;

1008 }

1009

1010 static int v4l2_is_v4l_dev(const char *name)

1011 {

1012 return !strncmp(name, "video", 5) ||

1013 !strncmp(name, "radio", 5) ||

1014 !strncmp(name, "vbi", 3) ||

1015 !strncmp(name, "v4l-subdev", 10);

1016 }

1017

1018 static int v4l2_get_device_list(AVFormatContext *ctx, AVDeviceInfoList *device_list)

1019 {

1020 struct video_data *s = ctx->priv_data;

1021 DIR *dir;

1022 struct dirent *entry;

1023 AVDeviceInfo *device = NULL;

1024 struct v4l2_capability cap;

1025 int ret = 0;

1026

1027 if (!device_list)

1028 return AVERROR(EINVAL);

1029

1030 dir = opendir("/dev");

1031 if (!dir) {

1032 ret = AVERROR(errno);

1033 av_log(ctx, AV_LOG_ERROR, "Couldn't open the directory: %s\n", av_err2str(ret));

1034 return ret;

1035 }

1036 while ((entry = readdir(dir))) {

1037 if (!v4l2_is_v4l_dev(entry->d_name))

1038 continue;

1039

1040 snprintf(ctx->filename, sizeof(ctx->filename), "/dev/%s", entry->d_name);

1041 if ((s->fd = device_open(ctx)) < 0)

1042 continue;

1043

1044 if (v4l2_ioctl(s->fd, VIDIOC_QUERYCAP, &cap) < 0) {

1045 ret = AVERROR(errno);

1046 av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_QUERYCAP): %s\n", av_err2str(ret));

1047 goto fail;

1048 }

1049

1050 device = av_mallocz(sizeof(AVDeviceInfo));

1051 if (!device) {

1052 ret = AVERROR(ENOMEM);

1053 goto fail;

1054 }

1055 device->device_name = av_strdup(ctx->filename);

1056 device->device_description = av_strdup(cap.card);

1057 if (!device->device_name || !device->device_description) {

1058 ret = AVERROR(ENOMEM);

1059 goto fail;

1060 }

1061

1062 if ((ret = av_dynarray_add_nofree(&device_list->devices,

1063 &device_list->nb_devices, device)) < 0)

1064 goto fail;

1065

1066 v4l2_close(s->fd);

1067 s->fd = -1;

1068 continue;

1069

1070 fail:

1071 if (device) {

1072 av_freep(&device->device_name);

1073 av_freep(&device->device_description);

1074 av_freep(&device);

1075 }

1076 if (s->fd >= 0)

1077 v4l2_close(s->fd);

1078 s->fd = -1;

1079 break;

1080 }

1081 closedir(dir);

1082 return ret;

1083 }

1084

1085 #define OFFSET(x) offsetof(struct video_data, x)

1086 #define DEC AV_OPT_FLAG_DECODING_PARAM

1087

1088 static const AVOption options[] = {

1089 { "standard", "set TV standard, used only by analog frame grabber", OFFSET(standard), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC },

1090 { "channel", "set TV channel, used only by frame grabber", OFFSET(channel), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, INT_MAX, DEC },

1091 { "video_size", "set frame size", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC },

1092 { "pixel_format", "set preferred pixel format", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1093 { "input_format", "set preferred pixel format (for raw video) or codec name", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1094 { "framerate", "set frame rate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1095

1096 { "list_formats", "list available formats and exit", OFFSET(list_format), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, DEC, "list_formats" },

1097 { "all", "show all available formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_ALLFORMATS }, 0, INT_MAX, DEC, "list_formats" },

1098 { "raw", "show only non-compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_RAWFORMATS }, 0, INT_MAX, DEC, "list_formats" },

1099 { "compressed", "show only compressed formats", OFFSET(list_format), AV_OPT_TYPE_CONST, {.i64 = V4L_COMPFORMATS }, 0, INT_MAX, DEC, "list_formats" },

1100

1101 { "list_standards", "list supported standards and exit", OFFSET(list_standard), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, DEC, "list_standards" },

1102 { "all", "show all supported standards", OFFSET(list_standard), AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, DEC, "list_standards" },

1103

1104 { "timestamps", "set type of timestamps for grabbed frames", OFFSET(ts_mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, "timestamps" },

1105 { "ts", "set type of timestamps for grabbed frames", OFFSET(ts_mode), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, DEC, "timestamps" },

1106 { "default", "use timestamps from the kernel", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_DEFAULT }, 0, 2, DEC, "timestamps" },

1107 { "abs", "use absolute timestamps (wall clock)", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_ABS }, 0, 2, DEC, "timestamps" },

1108 { "mono2abs", "force conversion from monotonic to absolute timestamps", OFFSET(ts_mode), AV_OPT_TYPE_CONST, {.i64 = V4L_TS_MONO2ABS }, 0, 2, DEC, "timestamps" },

1109 { "use_libv4l2", "use libv4l2 (v4l-utils) conversion functions", OFFSET(use_libv4l2), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC },

1110 { NULL },

1111 };

1112

1113 static const AVClass v4l2_class = {

1114 .class_name = "V4L2 indev",

1115 .item_name = av_default_item_name,

1116 .option = options,

1117 .version = LIBAVUTIL_VERSION_INT,

1118 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,

1119 };

1120