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 : %11s : %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, "Compressed: %11s : %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 pkt->size = 0;

503

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

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

506 if (res < 0) {

507 if (errno == EAGAIN)

508 return AVERROR(EAGAIN);

509

510 res = AVERROR(errno);

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

512 av_err2str(res));

513 return res;

514 }

515

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

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

518 return AVERROR(EINVAL);

519 }

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

521 // always keep at least one buffer queued

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

523

524 #ifdef V4L2_BUF_FLAG_ERROR

525 if (buf.flags & V4L2_BUF_FLAG_ERROR) {

526 av_log(ctx, AV_LOG_WARNING,

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

528 buf.bytesused);

529 buf.bytesused = 0;

530 } else

531 #endif

532 {

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

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

535 if (ctx->video_codec_id == AV_CODEC_ID_CPIA)

536 s->frame_size = buf.bytesused;

537

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

539 av_log(ctx, AV_LOG_ERROR,

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

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

542 enqueue_buffer(s, &buf);

543 return AVERROR_INVALIDDATA;

544 }

545 }

546

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

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

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

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

551 if (res < 0) {

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

553 enqueue_buffer(s, &buf);

554 return res;

555 }

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

557

558 res = enqueue_buffer(s, &buf);

559 if (res) {

560 av_free_packet(pkt);

561 return res;

562 }

563 } else {

564 struct buff_data *buf_descriptor;

565

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

567 pkt->size = buf.bytesused;

568 #if FF_API_DESTRUCT_PACKET

569 FF_DISABLE_DEPRECATION_WARNINGS

570 pkt->destruct = dummy_release_buffer;

571 FF_ENABLE_DEPRECATION_WARNINGS

572 #endif

573

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

575 if (!buf_descriptor) {

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

577 * allocate a buffer for memcpying into it

578 */

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

580 enqueue_buffer(s, &buf);

581

582 return AVERROR(ENOMEM);

583 }

584 buf_descriptor->index = buf.index;

585 buf_descriptor->s = s;

586

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

588 buf_descriptor, 0);

589 if (!pkt->buf) {

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

591 enqueue_buffer(s, &buf);

592 av_freep(&buf_descriptor);

593 return AVERROR(ENOMEM);

594 }

595 }

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

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

598

599 return pkt->size;

600 }

601

602 static int mmap_start(AVFormatContext *ctx)

603 {

604 struct video_data *s = ctx->priv_data;

605 enum v4l2_buf_type type;

606 int i, res;

607

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

609 struct v4l2_buffer buf = {

610 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,

611 .index = i,

612 .memory = V4L2_MEMORY_MMAP

613 };

614

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

616 res = AVERROR(errno);

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

618 av_err2str(res));

619 return res;

620 }

621 }

622 s->buffers_queued = s->buffers;

623

624 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

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

626 res = AVERROR(errno);

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

628 av_err2str(res));

629 return res;

630 }

631

632 return 0;

633 }

634

635 static void mmap_close(struct video_data *s)

636 {

637 enum v4l2_buf_type type;

638 int i;

639

640 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

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

642 * not do anything about it anyway...

643 */

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

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

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

647 }

648 av_freep(&s->buf_start);

649 av_freep(&s->buf_len);

650 }

651

652 static int v4l2_set_parameters(AVFormatContext *ctx)

653 {

654 struct video_data *s = ctx->priv_data;

655 struct v4l2_standard standard = { 0 };

656 struct v4l2_streamparm streamparm = { 0 };

657 struct v4l2_fract *tpf;

658 AVRational framerate_q = { 0 };

659 int i, ret;

660

661 if (s->framerate &&

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

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

664 s->framerate);

665 return ret;

666 }

667

668 if (s->standard) {

669 if (s->std_id) {

670 ret = 0;

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

672 /* set tv standard */

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

674 standard.index = i;

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

676 ret = AVERROR(errno);

677 break;

678 }

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

680 break;

681 }

682 if (ret < 0) {

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

684 return ret;

685 }

686

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

688 ret = AVERROR(errno);

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

690 return ret;

691 }

692 } else {

693 av_log(ctx, AV_LOG_WARNING,

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

695 }

696 }

697

698 /* get standard */

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

700 tpf = &standard.frameperiod;

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

702 standard.index = i;

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

704 ret = AVERROR(errno);

705 if (ret == AVERROR(EINVAL)

706 #ifdef ENODATA

707 || ret == AVERROR(ENODATA)

708 #endif

709 ) {

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

711 break;

712 }

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

714 return ret;

715 }

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

717 av_log(ctx, AV_LOG_DEBUG,

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

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

720 break;

721 }

722 }

723 } else {

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

725 }

726

727 streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

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

729 ret = AVERROR(errno);

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

731 return ret;

732 }

733

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

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

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

737

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

739 framerate_q.den, framerate_q.num);

740 tpf->numerator = framerate_q.den;

741 tpf->denominator = framerate_q.num;

742

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

744 ret = AVERROR(errno);

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

746 av_err2str(ret));

747 return ret;

748 }

749

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

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

752 av_log(ctx, AV_LOG_INFO,

753 "The driver changed the time per frame from "

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

755 framerate_q.den, framerate_q.num,

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

757 }

758 } else {

759 av_log(ctx, AV_LOG_WARNING,

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

761 }

762 }

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

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

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

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

767 } else

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

769

770 return 0;

771 }

772

773 static int device_try_init(AVFormatContext *ctx,

774 enum AVPixelFormat pix_fmt,

775 int *width,

776 int *height,

777 uint32_t *desired_format,

778 enum AVCodecID *codec_id)

779 {

780 int ret, i;

781

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

783

784 if (*desired_format) {

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

786 if (ret < 0) {

787 *desired_format = 0;

788 if (ret != AVERROR(EINVAL))

789 return ret;

790 }

791 }

792

793 if (!*desired_format) {

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

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

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

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

798 avcodec_get_name(ff_fmt_conversion_table[i].codec_id),

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

800

801 *desired_format = ff_fmt_conversion_table[i].v4l2_fmt;

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

803 if (ret >= 0)

804 break;

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

806 return ret;

807 *desired_format = 0;

808 }

809 }

810

811 if (*desired_format == 0) {

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

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

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

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

816 ret = AVERROR(EINVAL);

817 }

818 }

819

820 *codec_id = ff_fmt_v4l2codec(*desired_format);

821 av_assert0(*codec_id != AV_CODEC_ID_NONE);

822 return ret;

823 }

824

825 static int v4l2_read_probe(AVProbeData *p)

826 {

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

828 return AVPROBE_SCORE_MAX - 1;

829 return 0;

830 }

831

832 static int v4l2_read_header(AVFormatContext *ctx)

833 {

834 struct video_data *s = ctx->priv_data;

835 AVStream *st;

836 int res = 0;

837 uint32_t desired_format;

838 enum AVCodecID codec_id = AV_CODEC_ID_NONE;

839 enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;

840 struct v4l2_input input = { 0 };

841

842 st = avformat_new_stream(ctx, NULL);

843 if (!st)

844 return AVERROR(ENOMEM);

845

846 #if CONFIG_LIBV4L2

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

848 and errors will get sent to stderr */

849 if (s->use_libv4l2)

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

851 #endif

852

853 s->fd = device_open(ctx);

854 if (s->fd < 0)

855 return s->fd;

856

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

858 /* set video input */

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

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

861 res = AVERROR(errno);

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

863 goto fail;

864 }

865 } else {

866 /* get current video input */

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

868 res = AVERROR(errno);

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

870 goto fail;

871 }

872 }

873

874 /* enum input */

875 input.index = s->channel;

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

877 res = AVERROR(errno);

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

879 goto fail;

880 }

881 s->std_id = input.std;

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

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

884

885 if (s->list_format) {

886 list_formats(ctx, s->list_format);

887 res = AVERROR_EXIT;

888 goto fail;

889 }

890

891 if (s->list_standard) {

892 list_standards(ctx);

893 res = AVERROR_EXIT;

894 goto fail;

895 }

896

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

898

899 if (s->pixel_format) {

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

901

902 if (codec)

903 ctx->video_codec_id = codec->id;

904

905 pix_fmt = av_get_pix_fmt(s->pixel_format);

906

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

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

909 s->pixel_format);

910

911 res = AVERROR(EINVAL);

912 goto fail;

913 }

914 }

915

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

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

918

919 av_log(ctx, AV_LOG_VERBOSE,

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

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

922 res = AVERROR(errno);

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

924 av_err2str(res));

925 goto fail;

926 }

927

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

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

930 av_log(ctx, AV_LOG_VERBOSE,

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

932 }

933

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

935 if (res < 0)

936 goto fail;

937

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

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

940 * not be available outside this function

941 */

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

943 ctx->video_codec_id = codec_id;

944

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

946 goto fail;

947

948 s->pixelformat = desired_format;

949

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

951 goto fail;

952

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

954 s->frame_size =

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

956

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

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

959 goto fail;

960

961 s->top_field_first = first_field(s);

962

963 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

964 st->codec->codec_id = codec_id;

965 if (codec_id == AV_CODEC_ID_RAWVIDEO)

966 st->codec->codec_tag =

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

968 else if (codec_id == AV_CODEC_ID_H264) {

969 st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;

970 }

971 if (desired_format == V4L2_PIX_FMT_YVU420)

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

973 else if (desired_format == V4L2_PIX_FMT_YVU410)

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

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

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

977 if (st->avg_frame_rate.den)

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

979

980 return 0;

981

982 fail:

983 v4l2_close(s->fd);

984 return res;

985 }

986

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

988 {

989 struct video_data *s = ctx->priv_data;

990 #if FF_API_CODED_FRAME

991 FF_DISABLE_DEPRECATION_WARNINGS

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

993 FF_ENABLE_DEPRECATION_WARNINGS

994 #endif

995 int res;

996

997 av_init_packet(pkt);

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

999 return res;

1000 }

1001

1002 #if FF_API_CODED_FRAME

1003 FF_DISABLE_DEPRECATION_WARNINGS

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

1005 frame->interlaced_frame = 1;

1006 frame->top_field_first = s->top_field_first;

1007 }

1008 FF_ENABLE_DEPRECATION_WARNINGS

1009 #endif

1010

1011 return pkt->size;

1012 }

1013

1014 static int v4l2_read_close(AVFormatContext *ctx)

1015 {

1016 struct video_data *s = ctx->priv_data;

1017

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

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

1020 "close.\n");

1021

1022 mmap_close(s);

1023

1024 v4l2_close(s->fd);

1025 return 0;

1026 }

1027

1028 static int v4l2_is_v4l_dev(const char *name)

1029 {

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

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

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

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

1034 }

1035

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

1037 {

1038 struct video_data *s = ctx->priv_data;

1039 DIR *dir;

1040 struct dirent *entry;

1041 AVDeviceInfo *device = NULL;

1042 struct v4l2_capability cap;

1043 int ret = 0;

1044

1045 if (!device_list)

1046 return AVERROR(EINVAL);

1047

1048 dir = opendir("/dev");

1049 if (!dir) {

1050 ret = AVERROR(errno);

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

1052 return ret;

1053 }

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

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

1056 continue;

1057

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

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

1060 continue;

1061

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

1063 ret = AVERROR(errno);

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

1065 goto fail;

1066 }

1067

1068 device = av_mallocz(sizeof(AVDeviceInfo));

1069 if (!device) {

1070 ret = AVERROR(ENOMEM);

1071 goto fail;

1072 }

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

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

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

1076 ret = AVERROR(ENOMEM);

1077 goto fail;

1078 }

1079

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

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

1082 goto fail;

1083

1084 v4l2_close(s->fd);

1085 s->fd = -1;

1086 continue;

1087

1088 fail:

1089 if (device) {

1090 av_freep(&device->device_name);

1091 av_freep(&device->device_description);

1092 av_freep(&device);

1093 }

1094 if (s->fd >= 0)

1095 v4l2_close(s->fd);

1096 s->fd = -1;

1097 break;

1098 }

1099 closedir(dir);

1100 return ret;

1101 }

1102

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

1104 #define DEC AV_OPT_FLAG_DECODING_PARAM

1105

1106 static const AVOption options[] = {

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

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

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

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

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

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

1113

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

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

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

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

1118

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

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

1121

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

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

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

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

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

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

1128 { NULL },

1129 };

1130

1131 static const AVClass v4l2_class = {

1132 .class_name = "V4L2 indev",

1133 .item_name = av_default_item_name,

1134 .option = options,

1135 .version = LIBAVUTIL_VERSION_INT,

1136 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,

1137 };

1138

1139 AVInputFormat ff_v4l2_demuxer = {

1140 .name = "video4linux2,v4l2",

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

1142 .priv_data_size = sizeof(struct video_data),

1143 .read_probe = v4l2_read_probe,

1144 .read_header = v4l2_read_header,

1145 .read_packet = v4l2_read_packet,

1146 .read_close = v4l2_read_close,

1147 .get_device_list = v4l2_get_device_list,

1148 .flags = AVFMT_NOFILE,

1149 .priv_class = &v4l2_class,

1150 };

video_data::open_f

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

Definition: v4l2.c:93

NULL

#define NULL

Definition: coverity.c:32

AVDeviceInfo

Structure describes basic parameters of the device.

Definition: avdevice.h:451

avpriv_atomic_int_add_and_fetch

#define avpriv_atomic_int_add_and_fetch

Definition: atomic_gcc.h:50

const char * s

Definition: avisynth_c.h:631

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:103

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demuxing_decoding.c:40

av_free_packet

void av_free_packet(AVPacket *pkt)

Free a packet.

Definition: avpacket.c:280

AVFrame

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

Definition: frame.h:171

video_data::frame_size

int frame_size

Definition: v4l2.c:73

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:173

AV_PIX_FMT_NONE

Definition: pixfmt.h:62

AVOption

AVOption.

Definition: opt.h:255

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

video_data::dup_f

int(* dup_f)(int fd)

Definition: v4l2.c:95

video_data::read_f

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

Definition: v4l2.c:97

AVDeviceInfo::device_description

char * device_description

human friendly name

Definition: avdevice.h:453

device_init

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

Definition: v4l2.c:186

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:62

AVProbeData::filename

const char * filename

Definition: avformat.h:449

video_data::close_f

int(* close_f)(int fd)

Definition: v4l2.c:94

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:4083

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:87

AVDeviceInfo::device_name

char * device_name

device name, format depends on device

Definition: avdevice.h:452

AVRational::num

int num

numerator

Definition: rational.h:44

AVPacket::size

int size

Definition: avcodec.h:1424

fmt_map::codec_id

enum AVCodecID codec_id

Definition: v4l2-common.h:52

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1722

enqueue_buffer

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

Definition: v4l2.c:404

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:773

list_formats

static void list_formats(AVFormatContext *ctx, int type)

Definition: v4l2.c:269

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:623

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

video_data::buf_len

unsigned int * buf_len

Definition: v4l2.c:83

AV_CODEC_ID_H264

Definition: avcodec.h:135

AVCodec

AVCodec.

Definition: avcodec.h:3472

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:1273

video_data::channel

int channel

Definition: v4l2.c:86

video_data::buffers_queued

volatile int buffers_queued

Definition: v4l2.c:81

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:231

AVFMT_FLAG_NONBLOCK

#define AVFMT_FLAG_NONBLOCK

Do not block when reading packets from input.

Definition: avformat.h:1387

video_data::std_id

v4l2_std_id std_id

Definition: v4l2.c:85

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:54

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

mmap_read_frame

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

Definition: v4l2.c:493

init_convert_timestamp

static int init_convert_timestamp(AVFormatContext *ctx, int64_t ts)

Definition: v4l2.c:439

AVPacket::destruct

attribute_deprecated void(* destruct)(struct AVPacket *)

Definition: avcodec.h:1444

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:232

v4l2_close

#define v4l2_close

AVStream::need_parsing

enum AVStreamParseType need_parsing

Definition: avformat.h:1034

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:310

v4l2_read_header

static int v4l2_read_header(AVFormatContext *ctx)

Definition: v4l2.c:832

mmap_start

static int mmap_start(AVFormatContext *ctx)

Definition: v4l2.c:602

avformat_new_stream

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

Add a new stream to a media file.

Definition: utils.c:3749

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:1341

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

video_data::standard

char * standard

Definition: v4l2.c:84

desired_video_buffers

static const int desired_video_buffers

Definition: v4l2.c:40

av_q2d

static double av_q2d(AVRational a)

Convert rational to double.

Definition: rational.h:80

AV_OPT_TYPE_STRING

Definition: opt.h:227

AVFormatContext::flags

int flags

Flags modifying the (de)muxer behaviour.

Definition: avformat.h:1384

AVPacket::data

uint8_t * data

Definition: avcodec.h:1423

v4l2_is_v4l_dev

static int v4l2_is_v4l_dev(const char *name)

Definition: v4l2.c:1028

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

V4L_TS_DEFAULT

#define V4L_TS_DEFAULT

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

Definition: v4l2.c:49

v4l2_set_parameters

static int v4l2_set_parameters(AVFormatContext *ctx)

Definition: v4l2.c:652

device_open

static int device_open(AVFormatContext *ctx)

Definition: v4l2.c:107

AVFormatContext::video_codec_id

enum AVCodecID video_codec_id

Forced video codec_id.

Definition: avformat.h:1431

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:228

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:66

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:300

v4l2_get_device_list

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

Definition: v4l2.c:1036

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:140

video_data::height

int height

Definition: v4l2.c:72

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:83

video_data::interlaced

int interlaced

Definition: v4l2.c:74

AVCodec::id

enum AVCodecID id

Definition: avcodec.h:3486

v4l2-common.h

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: avcodec.h:102

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

av_default_item_name

Definition: libopenh264enc.c:59

AVERROR

#define AVERROR(e)

Definition: error.h:43

avpriv_atomic_int_get

#define avpriv_atomic_int_get

Definition: atomic_gcc.h:28

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:175

options

static const AVOption options[]

Definition: v4l2.c:1106

const char * r

Definition: vf_curves.c:107

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

AVPacket::buf

AVBufferRef * buf

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

Definition: avcodec.h:1406

video_data::buf_start

void ** buf_start

Definition: v4l2.c:82

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:92

codec_id

enum AVCodecID codec_id

Definition: mov_chan.c:433

AVDeviceInfoList::devices

AVDeviceInfo ** devices

list of autodetected devices

Definition: avdevice.h:460

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

OFFSET

#define OFFSET(x)

Definition: v4l2.c:1103

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:925

FFMAX

#define FFMAX(a, b)

Definition: common.h:79

fail

#define fail()

Definition: checkasm.h:57

V4L_TS_MONO2ABS

#define V4L_TS_MONO2ABS

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

Definition: v4l2.c:59

avcodec_descriptor_get

const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)

Definition: codec_desc.c:2935

AVStream::codec

AVCodecContext * codec

Codec context associated with this stream.

Definition: avformat.h:861

video_data::timefilter

TimeFilter * timefilter

Definition: v4l2.c:77

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:241

AVCodecContext::bit_rate

int bit_rate

the average bitrate

Definition: avcodec.h:1567

#define E

Definition: avdct.c:32

AVFormatContext::filename

char filename[1024]

input or output filename

Definition: avformat.h:1349

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:246

list_standards

static void list_standards(AVFormatContext *ctx)

Definition: v4l2.c:307

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:68

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1681

convert_timestamp

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

Definition: v4l2.c:472

mmap_close

static void mmap_close(struct video_data *s)

Definition: v4l2.c:635

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

video_data::ts_mode

int ts_mode

Definition: v4l2.c:76

int n

Definition: avisynth_c.h:547

AVCodecContext::height

int height

Definition: avcodec.h:1681

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:88

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:3035

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:842

AV_CODEC_ID_CPIA

Definition: avcodec.h:316

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

AVCodecContext::codec_type

enum AVMediaType codec_type

Definition: avcodec.h:1510

V4L_ALLFORMATS

#define V4L_ALLFORMATS

Definition: v4l2.c:42

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1519

av_strdup

char * av_strdup(const char *s)

Duplicate the string s.

Definition: mem.c:267

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:1534

buf

void * buf

Definition: avisynth_c.h:553

type

GLint GLenum type

Definition: opengl_enc.c:105

video_data::fd

int fd

Definition: v4l2.c:70

buff_data::s

struct video_data * s

Definition: v4l2.c:103

video_data::last_time_m

int64_t last_time_m

Definition: v4l2.c:78

height

BYTE int const BYTE int int int height

Definition: avisynth_c.h:676

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:1014

AVRational

rational number numerator/denominator

Definition: rational.h:43

video_data::width

int width

Definition: v4l2.c:72

AVCodecDescriptor::name

const char * name

Name of the codec described by this descriptor.

Definition: avcodec.h:574

snprintf

#define snprintf

Definition: snprintf.h:34

AV_OPT_TYPE_IMAGE_SIZE

offset must point to two consecutive integers

Definition: opt.h:232

AVProbeData

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

Definition: avformat.h:448

video_data::list_standard

int list_standard

Set by a private option.

Definition: v4l2.c:89

AVDeviceInfoList

List of devices.

Definition: avdevice.h:459

mmap_init

static int mmap_init(AVFormatContext *ctx)

Definition: v4l2.c:331

AVCodecDescriptor

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

Definition: avcodec.h:566

AVSTREAM_PARSE_FULL_ONCE

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

Definition: avformat.h:777

v4l2_class

static const AVClass v4l2_class

Definition: v4l2.c:1131

v4l2_read_packet

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

Definition: v4l2.c:987

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:3021

flags

static int flags

Definition: cpu.c:47

buff_data::index

int index

Definition: v4l2.c:104

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:460

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

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:79

video_data::buffers

int buffers

Definition: v4l2.c:80

AVFMT_NOFILE

#define AVFMT_NOFILE

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

Definition: avformat.h:465

video_data::framerate

char * framerate

Set by a private option.

Definition: v4l2.c:90

V4L_COMPFORMATS

#define V4L_COMPFORMATS

Definition: v4l2.c:44

AVCodecContext::coded_frame

attribute_deprecated AVFrame * coded_frame

the picture in the bitstream

Definition: avcodec.h:3024

av_init_packet

void av_init_packet(AVPacket *pkt)

Initialize optional fields of a packet with default values.

Definition: avpacket.c:49

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:45

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:80

V4L_RAWFORMATS

#define V4L_RAWFORMATS

Definition: v4l2.c:43

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1301

avpicture_get_size

int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height)

Calculate the size in bytes that a picture of the given width and height would occupy if stored in th...

Definition: avpicture.c:49

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:1139

DEC

#define DEC

Definition: v4l2.c:1104

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

start

void INT64 start

Definition: avisynth_c.h:553

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:628

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:193

fmt_map::v4l2_fmt

uint32_t v4l2_fmt

Definition: v4l2-common.h:53

mmap_release_buffer

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

Definition: v4l2.c:418

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

AV_CODEC_ID_RAWVIDEO

Definition: avcodec.h:121

av_get_pix_fmt

enum AVPixelFormat av_get_pix_fmt(const char *name)

Return the pixel format corresponding to name.

Definition: pixdesc.c:2062

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:2050

video_data::pixelformat

int pixelformat

Definition: v4l2.c:71

video_data::munmap_f

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

Definition: v4l2.c:99

v4l2_read_probe

static int v4l2_read_probe(AVProbeData *p)

Definition: v4l2.c:825

MKTAG

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

Definition: common.h:330

AVStream::r_frame_rate

AVRational r_frame_rate

Real base framerate of the stream.

Definition: avformat.h:1061

AVDeviceInfoList::nb_devices

int nb_devices

number of autodetected devices

Definition: avdevice.h:461

AVPixelFormat

Pixel format.

Definition: pixfmt.h:61

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1400

buff_data

Definition: v4l2.c:102

av_mallocz

void * av_mallocz(size_t size)

Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...

Definition: mem.c:252

video_data::ioctl_f

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

Definition: v4l2.c:96

AVPacket::pts

int64_t pts

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

Definition: avcodec.h:1416

buffer

GLuint buffer

Definition: opengl_enc.c:102

#define tb

Definition: regdef.h:68

name

const char * name

Definition: opengl_enc.c:103

width

static int width

Definition: demuxing_decoding.c:39

video_data::top_field_first

int top_field_first

Definition: v4l2.c:75

Generated on Thu Sep 10 2015 11:39:03 for FFmpeg by doxygen 1.8.6