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 <stdatomic.h>

35 #include "v4l2-common.h"

36 #include <dirent.h>

38 #if CONFIG_LIBV4L2

39 #include <libv4l2.h>

40 #endif

42 static const int desired_video_buffers = 256;

44 #define V4L_ALLFORMATS 3

45 #define V4L_RAWFORMATS 1

46 #define V4L_COMPFORMATS 2

48 /**

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

50 */

51 #define V4L_TS_DEFAULT 0

52 /**

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

54 * absolute (wall clock) timestamps.

55 */

56 #define V4L_TS_ABS 1

57 /**

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

59 * absolute timestamps.

60 */

61 #define V4L_TS_MONO2ABS 2

63 /**

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

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

66 * takes place.

67 */

68 #define V4L_TS_CONVERT_READY V4L_TS_DEFAULT

70 struct video_data {

71 AVClass *class;

72 int fd;

73 int pixelformat; /* V4L2_PIX_FMT_* */

74 int width, height;

75 int frame_size;

76 int interlaced;

77 int top_field_first;

78 int ts_mode;

79 TimeFilter *timefilter;

80 int64_t last_time_m;

82 int buffers;

83 atomic_int buffers_queued;

84 void **buf_start;

85 unsigned int *buf_len;

86 char *standard;

87 v4l2_std_id std_id;

88 int channel;

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

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

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

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

94 int use_libv4l2;

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

96 int (*close_f)(int fd);

97 int (*dup_f)(int fd);

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

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

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

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

102 };

103

104 struct buff_data {

105 struct video_data *s;

106 int index;

107 };

108

109 static int device_open(AVFormatContext *ctx)

110 {

111 struct video_data *s = ctx->priv_data;

112 struct v4l2_capability cap;

113 int fd;

114 int err;

115 int flags = O_RDWR;

116

117 #define SET_WRAPPERS(prefix) do { \

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

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

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

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

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

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

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

125 } while (0)

126

127 if (s->use_libv4l2) {

128 #if CONFIG_LIBV4L2

129 SET_WRAPPERS(v4l2_);

130 #else

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

132 return AVERROR(EINVAL);

133 #endif

134 } else {

135 SET_WRAPPERS();

136 }

137

138 #define v4l2_open s->open_f

139 #define v4l2_close s->close_f

140 #define v4l2_dup s->dup_f

141 #define v4l2_ioctl s->ioctl_f

142 #define v4l2_read s->read_f

143 #define v4l2_mmap s->mmap_f

144 #define v4l2_munmap s->munmap_f

145

146 if (ctx->flags & AVFMT_FLAG_NONBLOCK) {

147 flags |= O_NONBLOCK;

148 }

149

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

151 if (fd < 0) {

152 err = AVERROR(errno);

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

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

155 return err;

156 }

157

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

159 err = AVERROR(errno);

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

161 av_err2str(err));

162 goto fail;

163 }

164

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

166 fd, cap.capabilities);

167

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

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

170 err = AVERROR(ENODEV);

171 goto fail;

172 }

173

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

175 av_log(ctx, AV_LOG_ERROR,

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

177 err = AVERROR(ENOSYS);

178 goto fail;

179 }

180

181 return fd;

182

183 fail:

184 v4l2_close(fd);

185 return err;

186 }

187

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

189 uint32_t pixelformat)

190 {

191 struct video_data *s = ctx->priv_data;

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

193 int res = 0;

194

195 fmt.fmt.pix.width = *width;

196 fmt.fmt.pix.height = *height;

197 fmt.fmt.pix.pixelformat = pixelformat;

198 fmt.fmt.pix.field = V4L2_FIELD_ANY;

199

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

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

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

203 res = AVERROR(errno);

204

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

206 av_log(ctx, AV_LOG_INFO,

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

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

209 *width = fmt.fmt.pix.width;

210 *height = fmt.fmt.pix.height;

211 }

212

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

214 av_log(ctx, AV_LOG_DEBUG,

215 "The V4L2 driver changed the pixel format "

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

217 pixelformat, fmt.fmt.pix.pixelformat);

218 res = AVERROR(EINVAL);

219 }

220

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

222 av_log(ctx, AV_LOG_DEBUG,

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

224 s->interlaced = 1;

225 }

226

227 return res;

228 }

229

230 static int first_field(const struct video_data *s)

231 {

232 int res;

233 v4l2_std_id std;

234

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

236 if (res < 0)

237 return 0;

238 if (std & V4L2_STD_NTSC)

239 return 0;

240

241 return 1;

242 }

243

244 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE

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

246 {

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

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

249

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

251 switch (vfse.type) {

252 case V4L2_FRMSIZE_TYPE_DISCRETE:

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

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

255 break;

256 case V4L2_FRMSIZE_TYPE_CONTINUOUS:

257 case V4L2_FRMSIZE_TYPE_STEPWISE:

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

259 vfse.stepwise.min_width,

260 vfse.stepwise.max_width,

261 vfse.stepwise.step_width,

262 vfse.stepwise.min_height,

263 vfse.stepwise.max_height,

264 vfse.stepwise.step_height);

265 }

266 vfse.index++;

267 }

268 }

269 #endif

270

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

272 {

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

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

275

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

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

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

279

280 vfd.index++;

281

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

283 type & V4L_RAWFORMATS) {

284 const char *fmt_name = av_get_pix_fmt_name(pix_fmt);

285 av_log(ctx, AV_LOG_INFO, "Raw : %11s : %20s :",

286 fmt_name ? fmt_name : "Unsupported",

287 vfd.description);

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

289 type & V4L_COMPFORMATS) {

290 const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);

291 av_log(ctx, AV_LOG_INFO, "Compressed: %11s : %20s :",

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

293 vfd.description);

294 } else {

295 continue;

296 }

297

298 #ifdef V4L2_FMT_FLAG_EMULATED

299 if (vfd.flags & V4L2_FMT_FLAG_EMULATED)

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

301 #endif

302 #if HAVE_STRUCT_V4L2_FRMIVALENUM_DISCRETE

303 list_framesizes(ctx, vfd.pixelformat);

304 #endif

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

306 }

307 }

308

309 static void list_standards(AVFormatContext *ctx)

310 {

311 int ret;

312 struct video_data *s = ctx->priv_data;

313 struct v4l2_standard standard;

314

315 if (s->std_id == 0)

316 return;

317

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

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

320 ret = AVERROR(errno);

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

322 break;

323 } else {

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

325 return;

326 }

327 }

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

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

330 }

331 }

332

333 static int mmap_init(AVFormatContext *ctx)

334 {

335 int i, res;

336 struct video_data *s = ctx->priv_data;

337 struct v4l2_requestbuffers req = {

338 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

339 .count = desired_video_buffers,

340 .memory = V4L2_MEMORY_MMAP

341 };

342

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

344 res = AVERROR(errno);

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

346 return res;

347 }

348

349 if (req.count < 2) {

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

351 return AVERROR(ENOMEM);

352 }

353 s->buffers = req.count;

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

355 if (!s->buf_start) {

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

357 return AVERROR(ENOMEM);

358 }

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

360 if (!s->buf_len) {

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

362 av_freep(&s->buf_start);

363 return AVERROR(ENOMEM);

364 }

365

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

367 struct v4l2_buffer buf = {

368 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

369 .index = i,

370 .memory = V4L2_MEMORY_MMAP

371 };

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

373 res = AVERROR(errno);

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

375 return res;

376 }

377

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

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

380 av_log(ctx, AV_LOG_ERROR,

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

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

383 return AVERROR(ENOMEM);

384 }

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

386 PROT_READ | PROT_WRITE, MAP_SHARED,

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

388

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

390 res = AVERROR(errno);

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

392 return res;

393 }

394 }

395

396 return 0;

397 }

398

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

400 {

401 int res = 0;

402

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

404 res = AVERROR(errno);

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

406 } else {

407 atomic_fetch_add(&s->buffers_queued, 1);

408 }

409

410 return res;

411 }

412

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

414 {

415 struct v4l2_buffer buf = { 0 };

416 struct buff_data *buf_descriptor = opaque;

417 struct video_data *s = buf_descriptor->s;

418

419 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

420 buf.memory = V4L2_MEMORY_MMAP;

421 buf.index = buf_descriptor->index;

422 av_free(buf_descriptor);

423

424 enqueue_buffer(s, &buf);

425 }

426

427 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)

428 static int64_t av_gettime_monotonic(void)

429 {

430 return av_gettime_relative();

431 }

432 #endif

433

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

435 {

436 struct video_data *s = ctx->priv_data;

437 int64_t now;

438

439 now = av_gettime();

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

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

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

443 s->ts_mode = V4L_TS_CONVERT_READY;

444 return 0;

445 }

446 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)

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

448 now = av_gettime_monotonic();

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

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

451 AVRational tb = {AV_TIME_BASE, 1};

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

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

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

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

456 if (!s->timefilter)

457 return AVERROR(ENOMEM);

458 s->ts_mode = V4L_TS_CONVERT_READY;

459 return 0;

460 }

461 }

462 #endif

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

464 return AVERROR(EIO);

465 }

466

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

468 {

469 struct video_data *s = ctx->priv_data;

470

471 if (s->ts_mode) {

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

473 if (r < 0)

474 return r;

475 }

476 #if HAVE_CLOCK_GETTIME && defined(CLOCK_MONOTONIC)

477 if (s->timefilter) {

478 int64_t nowa = av_gettime();

479 int64_t nowm = av_gettime_monotonic();

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

481 s->last_time_m = nowm;

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

483 }

484 #endif

485 return 0;

486 }

487

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

489 {

490 struct video_data *s = ctx->priv_data;

491 struct v4l2_buffer buf = {

492 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

493 .memory = V4L2_MEMORY_MMAP

494 };

495 int res;

496

497 pkt->size = 0;

498

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

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

501 if (res < 0) {

502 if (errno == EAGAIN)

503 return AVERROR(EAGAIN);

504

505 res = AVERROR(errno);

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

507 av_err2str(res));

508 return res;

509 }

510

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

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

513 return AVERROR(EINVAL);

514 }

515 atomic_fetch_add(&s->buffers_queued, -1);

516 // always keep at least one buffer queued

517 av_assert0(atomic_load(&s->buffers_queued) >= 1);

518

519 #ifdef V4L2_BUF_FLAG_ERROR

520 if (buf.flags & V4L2_BUF_FLAG_ERROR) {

521 av_log(ctx, AV_LOG_WARNING,

522 "Dequeued v4l2 buffer contains corrupted data (%d bytes).\n",

523 buf.bytesused);

524 buf.bytesused = 0;

525 } else

526 #endif

527 {

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

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

530 if (ctx->video_codec_id == AV_CODEC_ID_CPIA)

531 s->frame_size = buf.bytesused;

532

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

534 av_log(ctx, AV_LOG_ERROR,

535 "Dequeued v4l2 buffer contains %d bytes, but %d were expected. Flags: 0x%08X.\n",

536 buf.bytesused, s->frame_size, buf.flags);

537 enqueue_buffer(s, &buf);

538 return AVERROR_INVALIDDATA;

539 }

540 }

541

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

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

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

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

546 if (res < 0) {

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

548 enqueue_buffer(s, &buf);

549 return res;

550 }

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

552

553 res = enqueue_buffer(s, &buf);

554 if (res) {

555 av_packet_unref(pkt);

556 return res;

557 }

558 } else {

559 struct buff_data *buf_descriptor;

560

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

562 pkt->size = buf.bytesused;

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 pkt->size;

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 atomic_store(&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_WARNING, "ioctl(VIDIOC_G_PARM): %s\n", av_err2str(ret));

721 } else if (framerate_q.num && framerate_q.den) {

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

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

724

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

726 framerate_q.den, framerate_q.num);

727 tpf->numerator = framerate_q.den;

728 tpf->denominator = framerate_q.num;

729

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

731 ret = AVERROR(errno);

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

733 av_err2str(ret));

734 return ret;

735 }

736

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

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

739 av_log(ctx, AV_LOG_INFO,

740 "The driver changed the time per frame from "

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

742 framerate_q.den, framerate_q.num,

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

744 }

745 } else {

746 av_log(ctx, AV_LOG_WARNING,

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

748 }

749 }

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

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

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

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

754 } else

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

756

757 return 0;

758 }

759

760 static int device_try_init(AVFormatContext *ctx,

761 enum AVPixelFormat pix_fmt,

762 int *width,

763 int *height,

764 uint32_t *desired_format,

765 enum AVCodecID *codec_id)

766 {

767 int ret, i;

768

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

770

771 if (*desired_format) {

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

773 if (ret < 0) {

774 *desired_format = 0;

775 if (ret != AVERROR(EINVAL))

776 return ret;

777 }

778 }

779

780 if (!*desired_format) {

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

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

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

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

785 avcodec_get_name(ff_fmt_conversion_table[i].codec_id),

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

787

788 *desired_format = ff_fmt_conversion_table[i].v4l2_fmt;

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

790 if (ret >= 0)

791 break;

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

793 return ret;

794 *desired_format = 0;

795 }

796 }

797

798 if (*desired_format == 0) {

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

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

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

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

803 ret = AVERROR(EINVAL);

804 }

805 }

806

807 *codec_id = ff_fmt_v4l2codec(*desired_format);

808 av_assert0(*codec_id != AV_CODEC_ID_NONE);

809 return ret;

810 }

811

812 static int v4l2_read_probe(AVProbeData *p)

813 {

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

815 return AVPROBE_SCORE_MAX - 1;

816 return 0;

817 }

818

819 static int v4l2_read_header(AVFormatContext *ctx)

820 {

821 struct video_data *s = ctx->priv_data;

822 AVStream *st;

823 int res = 0;

824 uint32_t desired_format;

825 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

826 enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;

827 struct v4l2_input input = { 0 };

828

829 st = avformat_new_stream(ctx, NULL);

830 if (!st)

831 return AVERROR(ENOMEM);

832

833 #if CONFIG_LIBV4L2

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

835 and errors will get sent to stderr */

836 if (s->use_libv4l2)

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

838 #endif

839

840 s->fd = device_open(ctx);

841 if (s->fd < 0)

842 return s->fd;

843

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

845 /* set video input */

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

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

848 res = AVERROR(errno);

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

850 goto fail;

851 }

852 } else {

853 /* get current video input */

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

855 res = AVERROR(errno);

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

857 goto fail;

858 }

859 }

860

861 /* enum input */

862 input.index = s->channel;

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

864 res = AVERROR(errno);

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

866 goto fail;

867 }

868 s->std_id = input.std;

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

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

871

872 if (s->list_format) {

873 list_formats(ctx, s->list_format);

874 res = AVERROR_EXIT;

875 goto fail;

876 }

877

878 if (s->list_standard) {

879 list_standards(ctx);

880 res = AVERROR_EXIT;

881 goto fail;

882 }

883

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

885

886 if (s->pixel_format) {

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

888

889 if (codec)

890 ctx->video_codec_id = codec->id;

891

892 pix_fmt = av_get_pix_fmt(s->pixel_format);

893

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

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

896 s->pixel_format);

897

898 res = AVERROR(EINVAL);

899 goto fail;

900 }

901 }

902

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

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

905

906 av_log(ctx, AV_LOG_VERBOSE,

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

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

909 res = AVERROR(errno);

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

911 av_err2str(res));

912 goto fail;

913 }

914

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

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

917 av_log(ctx, AV_LOG_VERBOSE,

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

919 }

920

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

922 if (res < 0)

923 goto fail;

924

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

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

927 * not be available outside this function

928 */

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

930 ctx->video_codec_id = codec_id;

931

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

933 goto fail;

934

935 s->pixelformat = desired_format;

936

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

938 goto fail;

939

940 st->codecpar->format = ff_fmt_v4l2ff(desired_format, codec_id);

941 if (st->codecpar->format != AV_PIX_FMT_NONE)

942 s->frame_size = av_image_get_buffer_size(st->codecpar->format,

943 s->width, s->height, 1);

944

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

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

947 goto fail;

948

949 s->top_field_first = first_field(s);

950

951 st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

952 st->codecpar->codec_id = codec_id;

953 if (codec_id == AV_CODEC_ID_RAWVIDEO)

954 st->codecpar->codec_tag =

955 avcodec_pix_fmt_to_codec_tag(st->codecpar->format);

956 else if (codec_id == AV_CODEC_ID_H264) {

957 st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;

958 }

959 if (desired_format == V4L2_PIX_FMT_YVU420)

960 st->codecpar->codec_tag = MKTAG('Y', 'V', '1', '2');

961 else if (desired_format == V4L2_PIX_FMT_YVU410)

962 st->codecpar->codec_tag = MKTAG('Y', 'V', 'U', '9');

963 st->codecpar->width = s->width;

964 st->codecpar->height = s->height;

965 if (st->avg_frame_rate.den)

966 st->codecpar->bit_rate = s->frame_size * av_q2d(st->avg_frame_rate) * 8;

967

968 return 0;

969

970 fail:

971 v4l2_close(s->fd);

972 return res;

973 }

974

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

976 {

977 #if FF_API_CODED_FRAME && FF_API_LAVF_AVCTX

978 FF_DISABLE_DEPRECATION_WARNINGS

979 struct video_data *s = ctx->priv_data;

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

981 FF_ENABLE_DEPRECATION_WARNINGS

982 #endif

983 int res;

984

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

986 return res;

987 }

988

989 #if FF_API_CODED_FRAME && FF_API_LAVF_AVCTX

990 FF_DISABLE_DEPRECATION_WARNINGS

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

992 frame->interlaced_frame = 1;

993 frame->top_field_first = s->top_field_first;

994 }

995 FF_ENABLE_DEPRECATION_WARNINGS

996 #endif

997

998 return pkt->size;

999 }

1000

1001 static int v4l2_read_close(AVFormatContext *ctx)

1002 {

1003 struct video_data *s = ctx->priv_data;

1004

1005 if (atomic_load(&s->buffers_queued) != s->buffers)

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

1007 "close.\n");

1008

1009 mmap_close(s);

1010

1011 v4l2_close(s->fd);

1012 return 0;

1013 }

1014

1015 static int v4l2_is_v4l_dev(const char *name)

1016 {

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

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

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

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

1021 }

1022

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

1024 {

1025 struct video_data *s = ctx->priv_data;

1026 DIR *dir;

1027 struct dirent *entry;

1028 AVDeviceInfo *device = NULL;

1029 struct v4l2_capability cap;

1030 int ret = 0;

1031

1032 if (!device_list)

1033 return AVERROR(EINVAL);

1034

1035 dir = opendir("/dev");

1036 if (!dir) {

1037 ret = AVERROR(errno);

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

1039 return ret;

1040 }

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

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

1043 continue;

1044

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

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

1047 continue;

1048

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

1050 ret = AVERROR(errno);

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

1052 goto fail;

1053 }

1054

1055 device = av_mallocz(sizeof(AVDeviceInfo));

1056 if (!device) {

1057 ret = AVERROR(ENOMEM);

1058 goto fail;

1059 }

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

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

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

1063 ret = AVERROR(ENOMEM);

1064 goto fail;

1065 }

1066

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

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

1069 goto fail;

1070

1071 v4l2_close(s->fd);

1072 s->fd = -1;

1073 continue;

1074

1075 fail:

1076 if (device) {

1077 av_freep(&device->device_name);

1078 av_freep(&device->device_description);

1079 av_freep(&device);

1080 }

1081 if (s->fd >= 0)

1082 v4l2_close(s->fd);

1083 s->fd = -1;

1084 break;

1085 }

1086 closedir(dir);

1087 return ret;

1088 }

1089

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

1091 #define DEC AV_OPT_FLAG_DECODING_PARAM

1092

1093 static const AVOption options[] = {

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

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

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

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

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

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

1100

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

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

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

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

1105

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

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

1108

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

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

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

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

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

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

1115 { NULL },

1116 };

1117

1118 static const AVClass v4l2_class = {

1119 .class_name = "V4L2 indev",

1120 .item_name = av_default_item_name,

1121 .option = options,

1122 .version = LIBAVUTIL_VERSION_INT,

1123 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,

1124 };

1125

1126 AVInputFormat ff_v4l2_demuxer = {

1127 .name = "video4linux2,v4l2",

1128 .long_name = NULL_IF_CONFIG_SMALL("Video4Linux2 device grab"),

1129 .priv_data_size = sizeof(struct video_data),

1130 .read_probe = v4l2_read_probe,

1131 .read_header = v4l2_read_header,

1132 .read_packet = v4l2_read_packet,

1133 .read_close = v4l2_read_close,

1134 .get_device_list = v4l2_get_device_list,

1135 .flags = AVFMT_NOFILE,

1136 .priv_class = &v4l2_class,

1137 };

video_data::open_f

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

Definition: v4l2.c:95

NULL

#define NULL

Definition: coverity.c:32

AVDeviceInfo

Structure describes basic parameters of the device.

Definition: avdevice.h:452

const char * s

Definition: avisynth_c.h:768

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

v4l2_mmap

#define v4l2_mmap

AV_CODEC_ID_NONE

Definition: avcodec.h:215

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demuxing_decoding.c:40

AVFrame

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

Definition: frame.h:187

video_data::frame_size

int frame_size

Definition: v4l2.c:75

av_parse_video_rate

int av_parse_video_rate(AVRational *rate, const char *arg)

Parse str and store the detected values in *rate.

Definition: parseutils.c:179

AV_PIX_FMT_NONE

Definition: pixfmt.h:61

atomic_store

#define atomic_store(object, desired)

Definition: stdatomic.h:85

AVOption

AVOption.

Definition: opt.h:246

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

video_data::dup_f

int(* dup_f)(int fd)

Definition: v4l2.c:97

video_data::read_f

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

Definition: v4l2.c:99

AVDeviceInfo::device_description

char * device_description

human friendly name

Definition: avdevice.h:454

device_init

static int device_init(AVFormatContext *ctx, int *width, int *height, uint32_t pixelformat)

Definition: v4l2.c:188

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVProbeData::filename

const char * filename

Definition: avformat.h:462

video_data::close_f

int(* close_f)(int fd)

Definition: v4l2.c:96

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: utils.c:4601

desc

const char * desc

Definition: nvenc.c:60

AV_OPT_TYPE_INT

Definition: opt.h:223

v4l2_open

#define v4l2_open

video_data::pixel_format

char * pixel_format

Set by a private option.

Definition: v4l2.c:89

AVDeviceInfo::device_name

char * device_name

device name, format depends on device

Definition: avdevice.h:453

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: avcodec.h:4066

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVPacket::size

int size

Definition: avcodec.h:1658

fmt_map::codec_id

enum AVCodecID codec_id

Definition: v4l2-common.h:51

enqueue_buffer

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

Definition: v4l2.c:399

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:222

device_try_init

static int device_try_init(AVFormatContext *ctx, enum AVPixelFormat pix_fmt, int *width, int *height, uint32_t *desired_format, enum AVCodecID *codec_id)

Definition: v4l2.c:760

list_formats

static void list_formats(AVFormatContext *ctx, int type)

Definition: v4l2.c:271

ff_fmt_ff2v4l

uint32_t ff_fmt_ff2v4l(enum AVPixelFormat pix_fmt, enum AVCodecID codec_id)

Definition: v4l2-common.c:64

AVInputFormat

Definition: avformat.h:659

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

ff_timefilter_eval

double ff_timefilter_eval(TimeFilter *self, double delta)

Evaluate the filter at a specified time.

Definition: timefilter.c:88

atomic_int

intptr_t atomic_int

Definition: stdatomic.h:55

video_data::buf_len

unsigned int * buf_len

Definition: v4l2.c:85

AV_CODEC_ID_H264

Definition: avcodec.h:247

AVCodec

AVCodec.

Definition: avcodec.h:3681

ff_fmt_conversion_table

const struct fmt_map ff_fmt_conversion_table[]

Definition: v4l2-common.c:21

AVFormatContext

Format I/O context.

Definition: avformat.h:1349

video_data::channel

int channel

Definition: v4l2.c:88

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:72

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AV_OPT_TYPE_CONST

Definition: opt.h:232

AVFMT_FLAG_NONBLOCK

#define AVFMT_FLAG_NONBLOCK

Do not block when reading packets from input.

Definition: avformat.h:1463

video_data::std_id

v4l2_std_id std_id

Definition: v4l2.c:87

V4L_TS_ABS

#define V4L_TS_ABS

Autodetect the kind of timestamps returned by the kernel and convert to absolute (wall clock) timesta...

Definition: v4l2.c:56

TimeFilter

Opaque type representing a time filter state.

Definition: timefilter.c:30

uint8_t

Definition: audio_convert.c:194

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

AVCodecParameters::width

int width

Video only.

Definition: avcodec.h:4132

mmap_read_frame

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

Definition: v4l2.c:488

init_convert_timestamp

static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts)

Definition: v4l2.c:434

avcodec_pix_fmt_to_codec_tag

unsigned int avcodec_pix_fmt_to_codec_tag(enum AVPixelFormat pix_fmt)

Return a value representing the fourCC code associated to the pixel format pix_fmt, or 0 if no associated fourCC code can be found.

Definition: raw.c:288

v4l2_close

#define v4l2_close

AVStream::need_parsing

enum AVStreamParseType need_parsing

Definition: avformat.h:1081

v4l2_read_header

static int v4l2_read_header(AVFormatContext *ctx)

Definition: v4l2.c:819

mmap_start

static int mmap_start(AVFormatContext *ctx)

Definition: v4l2.c:592

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)

Add a new stream to a media file.

Definition: utils.c:4231

AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT

Definition: log.h:42

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1417

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

video_data::standard

char * standard

Definition: v4l2.c:86

desired_video_buffers

static const int desired_video_buffers

Definition: v4l2.c:42

height

#define height

AV_OPT_TYPE_STRING

Definition: opt.h:227

AVFormatContext::flags

int flags

Flags modifying the (de)muxer behaviour.

Definition: avformat.h:1460

AVPacket::data

uint8_t * data

Definition: avcodec.h:1657

v4l2_is_v4l_dev

static int v4l2_is_v4l_dev(const char *name)

Definition: v4l2.c:1015

av_q2d

static double av_q2d(AVRational a)

Convert an AVRational to a double.

Definition: rational.h:104

flags

static int flags

Definition: log.c:57

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

AVFrame::interlaced_frame

int interlaced_frame

The content of the picture is interlaced.

Definition: frame.h:325

av_dynarray_add_nofree

int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)

Add an element to a dynamic array.

Definition: mem.c:280

V4L_TS_DEFAULT

#define V4L_TS_DEFAULT

Return timestamps to the user exactly as returned by the kernel.

Definition: v4l2.c:51

v4l2_set_parameters

static int v4l2_set_parameters(AVFormatContext *ctx)

Definition: v4l2.c:642

device_open

static int device_open(AVFormatContext *ctx)

Definition: v4l2.c:109

AVFormatContext::video_codec_id

enum AVCodecID video_codec_id

Forced video codec_id.

Definition: avformat.h:1513

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

first_field

static int first_field(const struct video_data *s)

Definition: v4l2.c:230

V4L_TS_CONVERT_READY

#define V4L_TS_CONVERT_READY

Once the kind of timestamps returned by the kernel have been detected, the value of the timefilter (N...

Definition: v4l2.c:68

AVCodecParameters::bit_rate

int64_t bit_rate

The average bitrate of the encoded data (in bits per second).

Definition: avcodec.h:4095

av_x_if_null

static void * av_x_if_null(const void *p, const void *x)

Return x default pointer in case p is NULL.

Definition: avutil.h:308

v4l2_get_device_list

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

Definition: v4l2.c:1023

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

video_data::height

int height

Definition: v4l2.c:74

av_new_packet

int av_new_packet(AVPacket *pkt, int size)

Allocate the payload of a packet and initialize its fields with default values.

Definition: avpacket.c:86

video_data::interlaced

int interlaced

Definition: v4l2.c:76

AVCodec::id

enum AVCodecID id

Definition: avcodec.h:3695

av_image_get_buffer_size

int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)

Return the size in bytes of the amount of data required to store an image with the given parameters...

Definition: imgutils.c:429

v4l2-common.h

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: avcodec.h:214

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

atomic_load

#define atomic_load(object)

Definition: stdatomic.h:93

av_default_item_name

Definition: libopenh264enc.c:78

AVERROR

#define AVERROR(e)

Definition: error.h:43

AVCodecParameters::format

int format

Definition: avcodec.h:4090

v4l2_munmap

#define v4l2_munmap

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:179

options

static const AVOption options[]

Definition: v4l2.c:1093

const char * r

Definition: vf_curves.c:111

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: avcodec.h:4062

AVPacket::buf

AVBufferRef * buf

A reference to the reference-counted buffer where the packet data is stored.

Definition: avcodec.h:1640

video_data::buf_start

void ** buf_start

Definition: v4l2.c:84

length

GLsizei GLsizei * length

Definition: opengl_enc.c:115

av_buffer_create

AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)

Create an AVBuffer from an existing array.

Definition: buffer.c:28

video_data::use_libv4l2

int use_libv4l2

Definition: v4l2.c:94

AVDeviceInfoList::devices

AVDeviceInfo ** devices

list of autodetected devices

Definition: avdevice.h:461

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

OFFSET

#define OFFSET(x)

Definition: v4l2.c:1090

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:970

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

fail

#define fail()

Definition: checkasm.h:89

V4L_TS_MONO2ABS

#define V4L_TS_MONO2ABS

Assume kernel timestamps are from the monotonic clock and convert to absolute timestamps.

Definition: v4l2.c:61

avcodec_descriptor_get

const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)

Definition: codec_desc.c:3063

video_data::timefilter

TimeFilter * timefilter

Definition: v4l2.c:79

av_image_check_size

int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)

Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...

Definition: imgutils.c:281

#define E

Definition: avdct.c:32

AVFormatContext::filename

char filename[1024]

input or output filename

Definition: avformat.h:1425

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:254

list_standards

static void list_standards(AVFormatContext *ctx)

Definition: v4l2.c:309

av_strcasecmp

int av_strcasecmp(const char *a, const char *b)

Locale-independent case-insensitive compare.

Definition: avstring.c:213

video_data

Definition: v4l2.c:70

width

#define width

convert_timestamp

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

Definition: v4l2.c:467

mmap_close

static void mmap_close(struct video_data *s)

Definition: v4l2.c:625

AVCodecParameters::height

int height

Definition: avcodec.h:4133

av_err2str

#define av_err2str(errnum)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: error.h:119

ctx

AVFormatContext * ctx

Definition: movenc.c:48

AV_OPT_TYPE_BOOL

Definition: opt.h:240

video_data::ts_mode

int ts_mode

Definition: v4l2.c:78

int n

Definition: avisynth_c.h:684

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:235

AVERROR_EXIT

#define AVERROR_EXIT

Immediate exit was requested; the called function should not be restarted.

Definition: error.h:56

video_data::list_format

int list_format

Set by a private option.

Definition: v4l2.c:90

v4l2_ioctl

#define v4l2_ioctl

avcodec_get_name

const char * avcodec_get_name(enum AVCodecID id)

Get the name of a codec.

Definition: utils.c:3187

av_gettime

int64_t av_gettime(void)

Get the current time in microseconds.

Definition: time.c:39

SET_WRAPPERS

#define SET_WRAPPERS(prefix)

AVStream

Stream structure.

Definition: avformat.h:889

atomic_fetch_add

#define atomic_fetch_add(object, operand)

Definition: stdatomic.h:131

AV_CODEC_ID_CPIA

Definition: avcodec.h:425

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

ff_timefilter_new

TimeFilter * ff_timefilter_new(double time_base, double period, double bandwidth)

Create a new Delay Locked Loop time filter.

Definition: timefilter.c:46

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:237

video_data::buffers_queued

atomic_int buffers_queued

Definition: v4l2.c:83

V4L_ALLFORMATS

#define V4L_ALLFORMATS

Definition: v4l2.c:44

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:589

buf

void * buf

Definition: avisynth_c.h:690

type

GLint GLenum type

Definition: opengl_enc.c:105

video_data::fd

int fd

Definition: v4l2.c:72

buff_data::s

struct video_data * s

Definition: v4l2.c:105

video_data::last_time_m

int64_t last_time_m

Definition: v4l2.c:80

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

v4l2_read_close

static int v4l2_read_close(AVFormatContext *ctx)

Definition: v4l2.c:1001

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

video_data::width

int width

Definition: v4l2.c:74

AVCodecDescriptor::name

const char * name

Name of the codec described by this descriptor.

Definition: avcodec.h:703

snprintf

#define snprintf

Definition: snprintf.h:34

AV_OPT_TYPE_IMAGE_SIZE

offset must point to two consecutive integers

Definition: opt.h:233

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:461

video_data::list_standard

int list_standard

Set by a private option.

Definition: v4l2.c:91

AVDeviceInfoList

List of devices.

Definition: avdevice.h:460

mmap_init

static int mmap_init(AVFormatContext *ctx)

Definition: v4l2.c:333

AVCodecDescriptor

This struct describes the properties of a single codec described by an AVCodecID. ...

Definition: avcodec.h:695

AVSTREAM_PARSE_FULL_ONCE

full parsing and repack of the first frame only, only implemented for H.264 currently ...

Definition: avformat.h:813

v4l2_class

static const AVClass v4l2_class

Definition: v4l2.c:1118

v4l2_read_packet

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

Definition: v4l2.c:975

av_gettime_relative

int64_t av_gettime_relative(void)

Get the current time in microseconds since some unspecified starting point.

Definition: time.c:56

avcodec_find_decoder_by_name

AVCodec * avcodec_find_decoder_by_name(const char *name)

Find a registered decoder with the specified name.

Definition: utils.c:3173

buff_data::index

int index

Definition: v4l2.c:106

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:473

av_strstart

int av_strstart(const char *str, const char *pfx, const char **ptr)

Return non-zero if pfx is a prefix of str.

Definition: avstring.c:34

int

Definition: ffmpeg_filter.c:190

ff_timefilter_update

double ff_timefilter_update(TimeFilter *self, double system_time, double period)

Update the filter.

Definition: timefilter.c:72

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:83

video_data::buffers

int buffers

Definition: v4l2.c:82

AVFMT_NOFILE

#define AVFMT_NOFILE

Demuxer will use avio_open, no opened file should be provided by the caller.

Definition: avformat.h:478

video_data::framerate

char * framerate

Set by a private option.

Definition: v4l2.c:92

V4L_COMPFORMATS

#define V4L_COMPFORMATS

Definition: v4l2.c:46

channel

Use these values when setting the channel map with ebur128_set_channel().

Definition: ebur128.h:39

ff_fmt_v4l2codec

enum AVCodecID ff_fmt_v4l2codec(uint32_t v4l2_fmt)

Definition: v4l2-common.c:94

AVRational::den

int den

Denominator.

Definition: rational.h:60

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:84

V4L_RAWFORMATS

#define V4L_RAWFORMATS

Definition: v4l2.c:45

AVFrame::top_field_first

int top_field_first

If the content is interlaced, is top field displayed first.

Definition: frame.h:330

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1377

ff_fmt_v4l2ff

enum AVPixelFormat ff_fmt_v4l2ff(uint32_t v4l2_fmt, enum AVCodecID codec_id)

Definition: v4l2-common.c:80

ff_v4l2_demuxer

AVInputFormat ff_v4l2_demuxer

Definition: v4l2.c:1126

DEC

#define DEC

Definition: v4l2.c:1091

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

start

void INT64 start

Definition: avisynth_c.h:690

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:664

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

fmt_map::v4l2_fmt

uint32_t v4l2_fmt

Definition: v4l2-common.h:52

mmap_release_buffer

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

Definition: v4l2.c:413

AVStream::codecpar

AVCodecParameters * codecpar

Definition: avformat.h:1252

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

AV_CODEC_ID_RAWVIDEO

Definition: avcodec.h:233

AVCodecParameters::codec_tag

uint32_t codec_tag

Additional information about the codec (corresponds to the AVI FOURCC).

Definition: avcodec.h:4070

av_get_pix_fmt

enum AVPixelFormat av_get_pix_fmt(const char *name)

Return the pixel format corresponding to name.

Definition: pixdesc.c:2261

av_get_pix_fmt_name

const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)

Return the short name for a pixel format, NULL in case pix_fmt is unknown.

Definition: pixdesc.c:2249

video_data::pixelformat

int pixelformat

Definition: v4l2.c:73

video_data::munmap_f

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

Definition: v4l2.c:101

v4l2_read_probe

static int v4l2_read_probe(AVProbeData *p)

Definition: v4l2.c:812

MKTAG

#define MKTAG(a, b, c, d)

Definition: common.h:342

AVStream::r_frame_rate

AVRational r_frame_rate

Real base framerate of the stream.

Definition: avformat.h:1108

AVDeviceInfoList::nb_devices

int nb_devices

number of autodetected devices

Definition: avdevice.h:462

AVPixelFormat

Pixel format.

Definition: pixfmt.h:60

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1634

buff_data

Definition: v4l2.c:104

video_data::ioctl_f

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

Definition: v4l2.c:98

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: avcodec.h:1650

buffer

GLuint buffer

Definition: opengl_enc.c:102

#define tb

Definition: regdef.h:68

name

const char * name

Definition: opengl_enc.c:103

video_data::top_field_first

int top_field_first

Definition: v4l2.c:77

Generated on Fri Jan 12 2018 01:45:50 for FFmpeg by doxygen 1.8.6