FFmpeg: libavformat/file.c Source File

FFmpeg

[フレーム]

libavformat

file.c

Go to the documentation of this file.

1 /*

2 * buffered file I/O

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 #include "config_components.h"

24 #include "libavutil/avstring.h"

25 #include "libavutil/file_open.h"

26 #include "libavutil/internal.h"

27 #include "libavutil/mem.h"

28 #include "libavutil/opt.h"

29 #include "avio.h"

30 #if HAVE_DIRENT_H

31 #include <dirent.h>

32 #endif

33 #include <fcntl.h>

34 #if HAVE_IO_H

35 #include <io.h>

36 #endif

37 #if HAVE_UNISTD_H

38 #include <unistd.h>

39 #endif

40 #include <sys/stat.h>

41 #include <stdlib.h>

42 #include "os_support.h"

43 #include "url.h"

45 /* Some systems may not have S_ISFIFO */

46 #ifndef S_ISFIFO

47 # ifdef S_IFIFO

48 # define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)

49 # else

50 # define S_ISFIFO(m) 0

51 # endif

52 #endif

54 /* Not available in POSIX.1-1996 */

55 #ifndef S_ISLNK

56 # ifdef S_IFLNK

57 # define S_ISLNK(m) (((m) & S_IFLNK) == S_IFLNK)

58 # else

59 # define S_ISLNK(m) 0

60 # endif

61 #endif

63 /* Not available in POSIX.1-1996 */

64 #ifndef S_ISSOCK

65 # ifdef S_IFSOCK

66 # define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)

67 # else

68 # define S_ISSOCK(m) 0

69 # endif

70 #endif

72 /* S_ISREG not available on Windows */

73 #ifndef S_ISREG

74 # ifdef S_IFREG

75 # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)

76 # else

77 # define S_ISREG(m) 0

78 # endif

79 #endif

81 /* S_ISBLK not available on Windows */

82 #ifndef S_ISBLK

83 # ifdef S_IFBLK

84 # define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)

85 # else

86 # define S_ISBLK(m) 0

87 # endif

88 #endif

90 /* standard file protocol */

92 typedef struct FileContext {

93 const AVClass *class;

94 int fd;

95 int trunc;

96 int blocksize;

97 int follow;

98 int seekable;

99 #if HAVE_DIRENT_H

100 DIR *dir;

101 #endif

102 } FileContext;

103

104 static const AVOption file_options[] = {

105 { "truncate", "truncate existing files on write", offsetof(FileContext, trunc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },

106 { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

107 { "follow", "Follow a file as it is being written", offsetof(FileContext, follow), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

108 { "seekable", "Sets if the file is seekable", offsetof(FileContext, seekable), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM },

109 { NULL }

110 };

111

112 static const AVOption pipe_options[] = {

113 { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

114 { "fd", "set file descriptor", offsetof(FileContext, fd), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

115 { NULL }

116 };

117

118 static const AVClass file_class = {

119 .class_name = "file",

120 .item_name = av_default_item_name,

121 .option = file_options,

122 .version = LIBAVUTIL_VERSION_INT,

123 };

124

125 static const AVClass pipe_class = {

126 .class_name = "pipe",

127 .item_name = av_default_item_name,

128 .option = pipe_options,

129 .version = LIBAVUTIL_VERSION_INT,

130 };

131

132 static const AVClass fd_class = {

133 .class_name = "fd",

134 .item_name = av_default_item_name,

135 .option = pipe_options,

136 .version = LIBAVUTIL_VERSION_INT,

137 };

138

139 static int file_read(URLContext *h, unsigned char *buf, int size)

140 {

141 FileContext *c = h->priv_data;

142 int ret;

143 size = FFMIN(size, c->blocksize);

144 ret = read(c->fd, buf, size);

145 if (ret == 0 && c->follow)

146 return AVERROR(EAGAIN);

147 if (ret == 0)

148 return AVERROR_EOF;

149 return (ret == -1) ? AVERROR(errno) : ret;

150 }

151

152 static int file_write(URLContext *h, const unsigned char *buf, int size)

153 {

154 FileContext *c = h->priv_data;

155 int ret;

156 size = FFMIN(size, c->blocksize);

157 ret = write(c->fd, buf, size);

158 return (ret == -1) ? AVERROR(errno) : ret;

159 }

160

161 static int file_get_handle(URLContext *h)

162 {

163 FileContext *c = h->priv_data;

164 return c->fd;

165 }

166

167 static int file_check(URLContext *h, int mask)

168 {

169 int ret = 0;

170 const char *filename = h->filename;

171 av_strstart(filename, "file:", &filename);

172

173 {

174 #if HAVE_ACCESS && defined(R_OK)

175 if (access(filename, F_OK) < 0)

176 return AVERROR(errno);

177 if (mask&AVIO_FLAG_READ)

178 if (access(filename, R_OK) >= 0)

179 ret |= AVIO_FLAG_READ;

180 if (mask&AVIO_FLAG_WRITE)

181 if (access(filename, W_OK) >= 0)

182 ret |= AVIO_FLAG_WRITE;

183 #else

184 struct stat st;

185 ret = stat(filename, &st);

186 if (ret < 0)

187 return AVERROR(errno);

188

189 ret |= st.st_mode&S_IRUSR ? mask&AVIO_FLAG_READ : 0;

190 ret |= st.st_mode&S_IWUSR ? mask&AVIO_FLAG_WRITE : 0;

191 #endif

192 }

193 return ret;

194 }

195

196 #if CONFIG_FD_PROTOCOL || CONFIG_PIPE_PROTOCOL

197 static int fd_dup(URLContext *h, int oldfd)

198 {

199 int newfd;

200

201 #ifdef F_DUPFD_CLOEXEC

202 newfd = fcntl(oldfd, F_DUPFD_CLOEXEC, 0);

203 #else

204 newfd = dup(oldfd);

205 #endif

206 if (newfd == -1)

207 return newfd;

208

209 #if HAVE_FCNTL

210 if (fcntl(newfd, F_SETFD, FD_CLOEXEC) == -1)

211 av_log(h, AV_LOG_DEBUG, "Failed to set close on exec\n");

212 #endif

213

214 #if HAVE_SETMODE

215 setmode(newfd, O_BINARY);

216 #endif

217 return newfd;

218 }

219 #endif

220

221 static int file_close(URLContext *h)

222 {

223 FileContext *c = h->priv_data;

224 int ret = close(c->fd);

225 return (ret == -1) ? AVERROR(errno) : 0;

226 }

227

228 /* XXX: use llseek */

229 static int64_t file_seek(URLContext *h, int64_t pos, int whence)

230 {

231 FileContext *c = h->priv_data;

232 int64_t ret;

233

234 if (whence == AVSEEK_SIZE) {

235 struct stat st;

236 ret = fstat(c->fd, &st);

237 return ret < 0 ? AVERROR(errno) : (S_ISFIFO(st.st_mode) ? 0 : st.st_size);

238 }

239

240 ret = lseek(c->fd, pos, whence);

241

242 return ret < 0 ? AVERROR(errno) : ret;

243 }

244

245 #if CONFIG_FILE_PROTOCOL

246

247 static int file_delete(URLContext *h)

248 {

249 #if HAVE_UNISTD_H

250 int ret;

251 const char *filename = h->filename;

252 av_strstart(filename, "file:", &filename);

253

254 ret = rmdir(filename);

255 if (ret < 0 && (errno == ENOTDIR

256 # ifdef _WIN32

257 || errno == EINVAL

258 # endif

259 ))

260 ret = unlink(filename);

261 if (ret < 0)

262 return AVERROR(errno);

263

264 return ret;

265 #else

266 return AVERROR(ENOSYS);

267 #endif /* HAVE_UNISTD_H */

268 }

269

270 static int file_move(URLContext *h_src, URLContext *h_dst)

271 {

272 const char *filename_src = h_src->filename;

273 const char *filename_dst = h_dst->filename;

274 av_strstart(filename_src, "file:", &filename_src);

275 av_strstart(filename_dst, "file:", &filename_dst);

276

277 if (rename(filename_src, filename_dst) < 0)

278 return AVERROR(errno);

279

280 return 0;

281 }

282

283 static int file_open(URLContext *h, const char *filename, int flags)

284 {

285 FileContext *c = h->priv_data;

286 int access;

287 int fd;

288 struct stat st;

289

290 av_strstart(filename, "file:", &filename);

291

292 if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {

293 access = O_CREAT | O_RDWR;

294 if (c->trunc)

295 access |= O_TRUNC;

296 } else if (flags & AVIO_FLAG_WRITE) {

297 access = O_CREAT | O_WRONLY;

298 if (c->trunc)

299 access |= O_TRUNC;

300 } else {

301 access = O_RDONLY;

302 }

303 #ifdef O_BINARY

304 access |= O_BINARY;

305 #endif

306 fd = avpriv_open(filename, access, 0666);

307 if (fd == -1)

308 return AVERROR(errno);

309 c->fd = fd;

310

311 h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode);

312

313 /* Buffer writes more than the default 32k to improve throughput especially

314 * with networked file systems */

315 if (!h->is_streamed && flags & AVIO_FLAG_WRITE)

316 h->min_packet_size = h->max_packet_size = 262144;

317

318 if (c->seekable >= 0)

319 h->is_streamed = !c->seekable;

320

321 return 0;

322 }

323

324 static int file_open_dir(URLContext *h)

325 {

326 #if HAVE_LSTAT

327 FileContext *c = h->priv_data;

328

329 c->dir = opendir(h->filename);

330 if (!c->dir)

331 return AVERROR(errno);

332

333 return 0;

334 #else

335 return AVERROR(ENOSYS);

336 #endif /* HAVE_LSTAT */

337 }

338

339 static int file_read_dir(URLContext *h, AVIODirEntry **next)

340 {

341 #if HAVE_LSTAT

342 FileContext *c = h->priv_data;

343 struct dirent *dir;

344 char *fullpath = NULL;

345

346 *next = ff_alloc_dir_entry();

347 if (!*next)

348 return AVERROR(ENOMEM);

349 do {

350 errno = 0;

351 dir = readdir(c->dir);

352 if (!dir) {

353 av_freep(next);

354 return AVERROR(errno);

355 }

356 } while (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."));

357

358 fullpath = av_append_path_component(h->filename, dir->d_name);

359 if (fullpath) {

360 struct stat st;

361 if (!lstat(fullpath, &st)) {

362 if (S_ISDIR(st.st_mode))

363 (*next)->type = AVIO_ENTRY_DIRECTORY;

364 else if (S_ISFIFO(st.st_mode))

365 (*next)->type = AVIO_ENTRY_NAMED_PIPE;

366 else if (S_ISCHR(st.st_mode))

367 (*next)->type = AVIO_ENTRY_CHARACTER_DEVICE;

368 else if (S_ISBLK(st.st_mode))

369 (*next)->type = AVIO_ENTRY_BLOCK_DEVICE;

370 else if (S_ISLNK(st.st_mode))

371 (*next)->type = AVIO_ENTRY_SYMBOLIC_LINK;

372 else if (S_ISSOCK(st.st_mode))

373 (*next)->type = AVIO_ENTRY_SOCKET;

374 else if (S_ISREG(st.st_mode))

375 (*next)->type = AVIO_ENTRY_FILE;

376 else

377 (*next)->type = AVIO_ENTRY_UNKNOWN;

378

379 (*next)->group_id = st.st_gid;

380 (*next)->user_id = st.st_uid;

381 (*next)->size = st.st_size;

382 (*next)->filemode = st.st_mode & 0777;

383 (*next)->modification_timestamp = INT64_C(1000000) * st.st_mtime;

384 (*next)->access_timestamp = INT64_C(1000000) * st.st_atime;

385 (*next)->status_change_timestamp = INT64_C(1000000) * st.st_ctime;

386 }

387 av_free(fullpath);

388 }

389

390 (*next)->name = av_strdup(dir->d_name);

391 return 0;

392 #else

393 return AVERROR(ENOSYS);

394 #endif /* HAVE_LSTAT */

395 }

396

397 static int file_close_dir(URLContext *h)

398 {

399 #if HAVE_LSTAT

400 FileContext *c = h->priv_data;

401 closedir(c->dir);

402 return 0;

403 #else

404 return AVERROR(ENOSYS);

405 #endif /* HAVE_LSTAT */

406 }

407

408 const URLProtocol ff_file_protocol = {

409 .name = "file",

410 .url_open = file_open,

411 .url_read = file_read,

412 .url_write = file_write,

413 .url_seek = file_seek,

414 .url_close = file_close,

415 .url_get_file_handle = file_get_handle,

416 .url_check = file_check,

417 .url_delete = file_delete,

418 .url_move = file_move,

419 .priv_data_size = sizeof(FileContext),

420 .priv_data_class = &file_class,

421 .url_open_dir = file_open_dir,

422 .url_read_dir = file_read_dir,

423 .url_close_dir = file_close_dir,

424 .default_whitelist = "file,crypto,data"

425 };

426

427 #endif /* CONFIG_FILE_PROTOCOL */

428

429 #if CONFIG_PIPE_PROTOCOL

430

431 static int pipe_open(URLContext *h, const char *filename, int flags)

432 {

433 FileContext *c = h->priv_data;

434 int fd;

435 char *final;

436

437 if (c->fd < 0) {

438 av_strstart(filename, "pipe:", &filename);

439

440 if (!*filename) {

441 if (flags & AVIO_FLAG_WRITE) {

442 fd = 1;

443 } else {

444 fd = 0;

445 }

446 } else {

447 fd = strtol(filename, &final, 10);

448 if (*final) /* No digits found, or something like 10ab */

449 return AVERROR(EINVAL);

450 }

451 c->fd = fd;

452 }

453

454 c->fd = fd_dup(h, c->fd);

455 if (c->fd == -1)

456 return AVERROR(errno);

457 h->is_streamed = 1;

458 return 0;

459 }

460

461 const URLProtocol ff_pipe_protocol = {

462 .name = "pipe",

463 .url_open = pipe_open,

464 .url_read = file_read,

465 .url_write = file_write,

466 .url_close = file_close,

467 .url_get_file_handle = file_get_handle,

468 .url_check = file_check,

469 .priv_data_size = sizeof(FileContext),

470 .priv_data_class = &pipe_class,

471 .default_whitelist = "crypto,data"

472 };

473

474 #endif /* CONFIG_PIPE_PROTOCOL */

475

476 #if CONFIG_FD_PROTOCOL

477

478 static int fd_open(URLContext *h, const char *filename, int flags)

479 {

480 FileContext *c = h->priv_data;

481 struct stat st;

482

483 if (strcmp(filename, "fd:") != 0) {

484 av_log(h, AV_LOG_ERROR, "Doesn't support pass file descriptor via URL,"

485 " please set it via -fd {num}\n");

486 return AVERROR(EINVAL);

487 }

488

489 if (c->fd < 0) {

490 if (flags & AVIO_FLAG_WRITE) {

491 c->fd = 1;

492 } else {

493 c->fd = 0;

494 }

495 }

496 if (fstat(c->fd, &st) < 0)

497 return AVERROR(errno);

498 h->is_streamed = !(S_ISREG(st.st_mode) || S_ISBLK(st.st_mode));

499 c->fd = fd_dup(h, c->fd);

500 if (c->fd == -1)

501 return AVERROR(errno);

502

503 return 0;

504 }

505

506 const URLProtocol ff_fd_protocol = {

507 .name = "fd",

508 .url_open = fd_open,

509 .url_read = file_read,

510 .url_write = file_write,

511 .url_seek = file_seek,

512 .url_close = file_close,

513 .url_get_file_handle = file_get_handle,

514 .url_check = file_check,

515 .priv_data_size = sizeof(FileContext),

516 .priv_data_class = &fd_class,

517 .default_whitelist = "crypto,data"

518 };

519

520 #endif /* CONFIG_FD_PROTOCOL */

521

522 #if CONFIG_ANDROID_CONTENT_PROTOCOL

523 #include <jni.h>

524 #include "libavcodec/ffjni.h"

525 #include "libavcodec/jni.h"

526

527 typedef struct JFields {

528 jclass uri_class;

529 jmethodID parse_id;

530

531 jclass context_class;

532 jmethodID get_content_resolver_id;

533

534 jclass content_resolver_class;

535 jmethodID open_file_descriptor_id;

536

537 jclass parcel_file_descriptor_class;

538 jmethodID detach_fd_id;

539 } JFields;

540

541 #define OFFSET(x) offsetof(JFields, x)

542 static const struct FFJniField jfields_mapping[] = {

543 { "android/net/Uri", NULL, NULL, FF_JNI_CLASS, OFFSET(uri_class), 1 },

544 { "android/net/Uri", "parse", "(Ljava/lang/String;)Landroid/net/Uri;", FF_JNI_STATIC_METHOD, OFFSET(parse_id), 1 },

545

546 { "android/content/Context", NULL, NULL, FF_JNI_CLASS, OFFSET(context_class), 1 },

547 { "android/content/Context", "getContentResolver", "()Landroid/content/ContentResolver;", FF_JNI_METHOD, OFFSET(get_content_resolver_id), 1 },

548

549 { "android/content/ContentResolver", NULL, NULL, FF_JNI_CLASS, OFFSET(content_resolver_class), 1 },

550 { "android/content/ContentResolver", "openFileDescriptor", "(Landroid/net/Uri;Ljava/lang/String;)Landroid/os/ParcelFileDescriptor;", FF_JNI_METHOD, OFFSET(open_file_descriptor_id), 1 },

551

552 { "android/os/ParcelFileDescriptor", NULL, NULL, FF_JNI_CLASS, OFFSET(parcel_file_descriptor_class), 1 },

553 { "android/os/ParcelFileDescriptor", "detachFd", "()I", FF_JNI_METHOD, OFFSET(detach_fd_id), 1 },

554

555 { NULL }

556 };

557 #undef OFFSET

558

559 static int android_content_open(URLContext *h, const char *filename, int flags)

560 {

561 FileContext *c = h->priv_data;

562 int fd, ret;

563 struct stat st;

564 const char *mode_str = "r";

565

566 JNIEnv *env;

567 JFields jfields = { 0 };

568 jobject application_context = NULL;

569 jobject url = NULL;

570 jobject mode = NULL;

571 jobject uri = NULL;

572 jobject content_resolver = NULL;

573 jobject parcel_file_descriptor = NULL;

574

575 env = ff_jni_get_env(c);

576 if (!env) {

577 return AVERROR(EINVAL);

578 }

579

580 ret = ff_jni_init_jfields(env, &jfields, jfields_mapping, 0, c);

581 if (ret < 0) {

582 av_log(c, AV_LOG_ERROR, "failed to initialize jni fields\n");

583 return ret;

584 }

585

586 application_context = av_jni_get_android_app_ctx();

587 if (!application_context) {

588 av_log(c, AV_LOG_ERROR, "application context is not set\n");

589 ret = AVERROR_EXTERNAL;

590 goto done;

591 }

592

593 url = ff_jni_utf_chars_to_jstring(env, filename, c);

594 if (!url) {

595 ret = AVERROR_EXTERNAL;

596 goto done;

597 }

598

599 if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ)

600 mode_str = "rw";

601 else if (flags & AVIO_FLAG_WRITE)

602 mode_str = "w";

603

604 mode = ff_jni_utf_chars_to_jstring(env, mode_str, c);

605 if (!mode) {

606 ret = AVERROR_EXTERNAL;

607 goto done;

608 }

609

610 uri = (*env)->CallStaticObjectMethod(env, jfields.uri_class, jfields.parse_id, url);

611 ret = ff_jni_exception_check(env, 1, c);

612 if (ret < 0)

613 goto done;

614

615 content_resolver = (*env)->CallObjectMethod(env, application_context, jfields.get_content_resolver_id);

616 ret = ff_jni_exception_check(env, 1, c);

617 if (ret < 0)

618 goto done;

619

620 parcel_file_descriptor = (*env)->CallObjectMethod(env, content_resolver, jfields.open_file_descriptor_id, uri, mode);

621 ret = ff_jni_exception_check(env, 1, c);

622 if (ret < 0)

623 goto done;

624

625 fd = (*env)->CallIntMethod(env, parcel_file_descriptor, jfields.detach_fd_id);

626 ret = ff_jni_exception_check(env, 1, c);

627 if (ret < 0)

628 goto done;

629

630 if (fstat(fd, &st) < 0) {

631 close(fd);

632 return AVERROR(errno);

633 }

634

635 c->fd = fd;

636 h->is_streamed = !(S_ISREG(st.st_mode) || S_ISBLK(st.st_mode));

637

638 done:

639 (*env)->DeleteLocalRef(env, url);

640 (*env)->DeleteLocalRef(env, mode);

641 (*env)->DeleteLocalRef(env, uri);

642 (*env)->DeleteLocalRef(env, content_resolver);

643 (*env)->DeleteLocalRef(env, parcel_file_descriptor);

644 ff_jni_reset_jfields(env, &jfields, jfields_mapping, 0, c);

645

646 return ret;

647 }

648

649 static const AVOption android_content_options[] = {

650 { "blocksize", "set I/O operation maximum block size", offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

651 { NULL }

652 };

653

654 static const AVClass android_content_class = {

655 .class_name = "android_content",

656 .item_name = av_default_item_name,

657 .option = android_content_options,

658 .version = LIBAVUTIL_VERSION_INT,

659 };

660

661 const URLProtocol ff_android_content_protocol = {

662 .name = "content",

663 .url_open = android_content_open,

664 .url_read = file_read,

665 .url_write = file_write,

666 .url_seek = file_seek,

667 .url_close = file_close,

668 .url_get_file_handle = file_get_handle,

669 .url_check = NULL,

670 .priv_data_size = sizeof(FileContext),

671 .priv_data_class = &android_content_class,

672 };

673

674 #endif /* CONFIG_ANDROID_CONTENT_PROTOCOL */

AVERROR

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

opt.h

S_ISSOCK

#define S_ISSOCK(m)

Definition: file.c:68

URLContext::filename

char * filename

specified URL

Definition: url.h:39

ff_jni_utf_chars_to_jstring

jstring ff_jni_utf_chars_to_jstring(JNIEnv *env, const char *utf_chars, void *log_ctx)

Definition: ffjni.c:129

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

int64_t

long long int64_t

Definition: coverity.c:34

mask

int mask

Definition: mediacodecdec_common.c:154

file_close

static int file_close(URLContext *h)

Definition: file.c:221

ff_jni_reset_jfields

int ff_jni_reset_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)

Definition: ffjni.c:368

AVOption

AVOption.

Definition: opt.h:429

AVSEEK_SIZE

#define AVSEEK_SIZE

ORing this as the "whence" parameter to a seek function causes it to return the filesize without seek...

Definition: avio.h:468

AVIO_ENTRY_NAMED_PIPE

@ AVIO_ENTRY_NAMED_PIPE

Definition: avio.h:72

file_check

static int file_check(URLContext *h, int mask)

Definition: file.c:167

URLProtocol

Definition: url.h:51

os_support.h

AVIO_ENTRY_UNKNOWN

@ AVIO_ENTRY_UNKNOWN

Definition: avio.h:68

ff_jni_init_jfields

int ff_jni_init_jfields(JNIEnv *env, void *jfields, const struct FFJniField *jfields_mapping, int global, void *log_ctx)

Definition: ffjni.c:279

av_append_path_component

char * av_append_path_component(const char *path, const char *component)

Append path component to the existing path.

Definition: avstring.c:296

AVIO_ENTRY_DIRECTORY

@ AVIO_ENTRY_DIRECTORY

Definition: avio.h:71

trunc

static __device__ float trunc(float a)

Definition: cuda_runtime.h:179

AVIO_ENTRY_CHARACTER_DEVICE

@ AVIO_ENTRY_CHARACTER_DEVICE

Definition: avio.h:70

FF_JNI_CLASS

@ FF_JNI_CLASS

Definition: ffjni.h:91

ff_android_content_protocol

const URLProtocol ff_android_content_protocol

FileContext::blocksize

int blocksize

Definition: file.c:96

file_write

static int file_write(URLContext *h, const unsigned char *buf, int size)

Definition: file.c:152

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

ff_fd_protocol

const URLProtocol ff_fd_protocol

file_read

static int file_read(URLContext *h, unsigned char *buf, int size)

Definition: file.c:139

AVIO_ENTRY_SYMBOLIC_LINK

@ AVIO_ENTRY_SYMBOLIC_LINK

Definition: avio.h:73

FileContext::seekable

int seekable

Definition: file.c:98

S_ISFIFO

#define S_ISFIFO(m)

Definition: file.c:50

avpriv_open

int avpriv_open(const char *filename, int flags,...)

A wrapper for open() setting O_CLOEXEC.

Definition: file_open.c:67

AVIO_FLAG_WRITE

#define AVIO_FLAG_WRITE

write-only

Definition: avio.h:618

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

FileContext

Definition: file.c:92

pipe_class

static const AVClass pipe_class

Definition: file.c:125

file_open.h

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

FF_JNI_METHOD

@ FF_JNI_METHOD

Definition: ffjni.h:94

NULL

#define NULL

Definition: coverity.c:32

S_ISBLK

#define S_ISBLK(m)

Definition: file.c:86

FFJniField

Definition: ffjni.h:103

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

AVIO_ENTRY_FILE

@ AVIO_ENTRY_FILE

Definition: avio.h:75

FileContext::fd

int fd

Definition: file.c:94

AV_OPT_FLAG_ENCODING_PARAM

#define AV_OPT_FLAG_ENCODING_PARAM

A generic parameter which can be set by the user for muxing or encoding.

Definition: opt.h:352

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

pipe_options

static const AVOption pipe_options[]

Definition: file.c:112

FileContext::follow

int follow

Definition: file.c:97

ff_file_protocol

const URLProtocol ff_file_protocol

size

int size

Definition: twinvq_data.h:10344

AVIODirEntry

Describes single entry of the directory.

Definition: avio.h:87

avio.h

URLProtocol::name

const char * name

Definition: url.h:52

FileContext::trunc

int trunc

Definition: file.c:95

file_seek

static int64_t file_seek(URLContext *h, int64_t pos, int whence)

Definition: file.c:229

AVERROR_EXTERNAL

#define AVERROR_EXTERNAL

Generic error in an external library.

Definition: error.h:59

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

AVIO_ENTRY_SOCKET

@ AVIO_ENTRY_SOCKET

Definition: avio.h:74

ff_alloc_dir_entry

AVIODirEntry * ff_alloc_dir_entry(void)

Allocate directory entry with default values.

Definition: url.c:327

ff_jni_exception_check

int ff_jni_exception_check(JNIEnv *env, int log, void *log_ctx)

Definition: ffjni.c:246

URLContext

Definition: url.h:35

ffjni.h

file_options

static const AVOption file_options[]

Definition: file.c:104

av_jni_get_android_app_ctx

void * av_jni_get_android_app_ctx(void)

internal.h

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

url.h

file_class

static const AVClass file_class

Definition: file.c:118

S_ISLNK

#define S_ISLNK(m)

Definition: file.c:59

O_BINARY

#define O_BINARY

ff_pipe_protocol

const URLProtocol ff_pipe_protocol

AVIO_ENTRY_BLOCK_DEVICE

@ AVIO_ENTRY_BLOCK_DEVICE

Definition: avio.h:69

ret

Definition: filter_design.txt:187

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

file_get_handle

static int file_get_handle(URLContext *h)

Definition: file.c:161

pos

unsigned int pos

Definition: spdifenc.c:414

OFFSET

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro

mode

Definition: ebur128.h:83

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

fd_class

static const AVClass fd_class

Definition: file.c:132

ff_jni_get_env

JNIEnv * ff_jni_get_env(void *log_ctx)

Definition: ffjni.c:53