FFmpeg: libavformat/udp.c Source File

128 { "burst_bits", "Max length of bursts in bits (when using bitrate)", OFFSET(burst_bits), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, .flags = E },

129 { "localport", "Local port", OFFSET(local_port), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, D|E },

130 { "local_port", "Local port", OFFSET(local_port), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, .flags = D|E },

131 { "localaddr", "Local address", OFFSET(localaddr), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },

132 { "udplite_coverage", "choose UDPLite head size which should be validated by checksum", OFFSET(udplite_coverage), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, D|E },

133 { "pkt_size", "Maximum UDP packet size", OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = 1472 }, -1, INT_MAX, .flags = D|E },

134 { "reuse", "explicitly allow reusing UDP sockets", OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, D|E },

135 { "reuse_socket", "explicitly allow reusing UDP sockets", OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, .flags = D|E },

136 { "broadcast", "explicitly allow or disallow broadcast destination", OFFSET(is_broadcast), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },

137 { "ttl", "Time to live (multicast only)", OFFSET(ttl), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 255, E },

138 { "connect", "set if connect() should be called on socket", OFFSET(is_connected), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, .flags = D|E },

139 { "fifo_size", "set the UDP receiving circular buffer size, expressed as a number of packets with size of 188 bytes", OFFSET(circular_buffer_size), AV_OPT_TYPE_INT, {.i64 = 7*4096}, 0, INT_MAX, D },

140 { "overrun_nonfatal", "survive in case of UDP receiving circular buffer overrun", OFFSET(overrun_nonfatal), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, D },

141 { "timeout", "set raise error timeout, in microseconds (only in read mode)",OFFSET(timeout), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, D },

142 { "sources", "Source list", OFFSET(sources), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },

143 { "block", "Block list", OFFSET(block), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = D|E },

144 { NULL }

145 };

146

147 static const AVClass udp_class = {

148 .class_name = "udp",

149 .item_name = av_default_item_name,

150 .option = options,

151 .version = LIBAVUTIL_VERSION_INT,

152 };

153

154 static const AVClass udplite_context_class = {

155 .class_name = "udplite",

156 .item_name = av_default_item_name,

157 .option = options,

158 .version = LIBAVUTIL_VERSION_INT,

159 };

160

161 static int udp_set_multicast_ttl(int sockfd, int mcastTTL,

162 struct sockaddr *addr,

163 void *logctx)

164 {

165 int protocol, cmd;

166

167 /* There is some confusion in the world whether IP_MULTICAST_TTL

168 * takes a byte or an int as an argument.

169 * BSD seems to indicate byte so we are going with that and use

170 * int and fall back to byte to be safe */

171 switch (addr->sa_family) {

172 #ifdef IP_MULTICAST_TTL

173 case AF_INET:

174 protocol = IPPROTO_IP;

175 cmd = IP_MULTICAST_TTL;

176 break;

177 #endif

178 #ifdef IPV6_MULTICAST_HOPS

179 case AF_INET6:

180 protocol = IPPROTO_IPV6;

181 cmd = IPV6_MULTICAST_HOPS;

182 break;

183 #endif

184 default:

185 return 0;

186 }

187

188 if (setsockopt(sockfd, protocol, cmd, &mcastTTL, sizeof(mcastTTL)) < 0) {

189 /* BSD compatibility */

190 unsigned char ttl = (unsigned char) mcastTTL;

191

192 ff_log_net_error(logctx, AV_LOG_DEBUG, "setsockopt(IPV4/IPV6 MULTICAST TTL)");

193 if (setsockopt(sockfd, protocol, cmd, &ttl, sizeof(ttl)) < 0) {

194 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV4/IPV6 MULTICAST TTL)");

195 return ff_neterrno();

196 }

197 }

198

199 return 0;

200 }

201

202 static int udp_join_multicast_group(int sockfd, struct sockaddr *addr,

203 struct sockaddr *local_addr, void *logctx)

204 {

205 #ifdef IP_ADD_MEMBERSHIP

206 if (addr->sa_family == AF_INET) {

207 struct ip_mreq mreq;

208

209 mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;

210 if (local_addr)

211 mreq.imr_interface= ((struct sockaddr_in *)local_addr)->sin_addr;

212 else

213 mreq.imr_interface.s_addr = INADDR_ANY;

214 if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {

215 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IP_ADD_MEMBERSHIP)");

216 return ff_neterrno();

217 }

218 }

219 #endif

220 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)

221 if (addr->sa_family == AF_INET6) {

222 struct ipv6_mreq mreq6;

223

224 memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));

225 //TODO: Interface index should be looked up from local_addr

226 mreq6.ipv6mr_interface = 0;

227 if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {

228 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV6_ADD_MEMBERSHIP)");

229 return ff_neterrno();

230 }

231 }

232 #endif

233 return 0;

234 }

235

236 static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr,

237 struct sockaddr *local_addr, void *logctx)

238 {

239 #ifdef IP_DROP_MEMBERSHIP

240 if (addr->sa_family == AF_INET) {

241 struct ip_mreq mreq;

242

243 mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;

244 if (local_addr)

245 mreq.imr_interface = ((struct sockaddr_in *)local_addr)->sin_addr;

246 else

247 mreq.imr_interface.s_addr = INADDR_ANY;

248 if (setsockopt(sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {

249 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IP_DROP_MEMBERSHIP)");

250 return -1;

251 }

252 }

253 #endif

254 #if HAVE_STRUCT_IPV6_MREQ && defined(IPPROTO_IPV6)

255 if (addr->sa_family == AF_INET6) {

256 struct ipv6_mreq mreq6;

257

258 memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));

259 //TODO: Interface index should be looked up from local_addr

260 mreq6.ipv6mr_interface = 0;

261 if (setsockopt(sockfd, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {

262 ff_log_net_error(logctx, AV_LOG_ERROR, "setsockopt(IPV6_DROP_MEMBERSHIP)");

263 return -1;

264 }

265 }

266 #endif

267 return 0;

268 }

269

270 static int udp_set_multicast_sources(URLContext *h,

271 int sockfd, struct sockaddr *addr,

272 int addr_len, struct sockaddr_storage *local_addr,

273 struct sockaddr_storage *sources,

274 int nb_sources, int include)

275 {

276 int i;

277 if (addr->sa_family != AF_INET) {

278 #if HAVE_STRUCT_GROUP_SOURCE_REQ && defined(MCAST_BLOCK_SOURCE)

279 /* For IPv4 prefer the old approach, as that alone works reliably on

280 * Windows and it also supports supplying the interface based on its

281 * address. */

282 int i;

283 for (i = 0; i < nb_sources; i++) {

284 struct group_source_req mreqs;

285 int level = addr->sa_family == AF_INET ? IPPROTO_IP : IPPROTO_IPV6;

286

287 //TODO: Interface index should be looked up from local_addr

288 mreqs.gsr_interface = 0;

289 memcpy(&mreqs.gsr_group, addr, addr_len);

290 memcpy(&mreqs.gsr_source, &sources[i], sizeof(*sources));

291

292 if (setsockopt(sockfd, level,

293 include ? MCAST_JOIN_SOURCE_GROUP : MCAST_BLOCK_SOURCE,

294 (const void *)&mreqs, sizeof(mreqs)) < 0) {

295 if (include)

296 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(MCAST_JOIN_SOURCE_GROUP)");

297 else

298 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(MCAST_BLOCK_SOURCE)");

299 return ff_neterrno();

300 }

301 }

302 return 0;

303 #else

304 av_log(h, AV_LOG_ERROR,

305 "Setting multicast sources only supported for IPv4\n");

306 return AVERROR(EINVAL);

307 #endif

308 }

309 #if HAVE_STRUCT_IP_MREQ_SOURCE && defined(IP_BLOCK_SOURCE)

310 for (i = 0; i < nb_sources; i++) {

311 struct ip_mreq_source mreqs;

312 if (sources[i].ss_family != AF_INET) {

313 av_log(h, AV_LOG_ERROR, "Source/block address %d is of incorrect protocol family\n", i + 1);

314 return AVERROR(EINVAL);

315 }

316

317 mreqs.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;

318 if (local_addr)

319 mreqs.imr_interface = ((struct sockaddr_in *)local_addr)->sin_addr;

320 else

321 mreqs.imr_interface.s_addr = INADDR_ANY;

322 mreqs.imr_sourceaddr.s_addr = ((struct sockaddr_in *)&sources[i])->sin_addr.s_addr;

323

324 if (setsockopt(sockfd, IPPROTO_IP,

325 include ? IP_ADD_SOURCE_MEMBERSHIP : IP_BLOCK_SOURCE,

326 (const void *)&mreqs, sizeof(mreqs)) < 0) {

327 if (include)

328 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(IP_ADD_SOURCE_MEMBERSHIP)");

329 else

330 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(IP_BLOCK_SOURCE)");

331 return ff_neterrno();

332 }

333 }

334 #else

335 return AVERROR(ENOSYS);

336 #endif

337 return 0;

338 }

339 static int udp_set_url(URLContext *h,

340 struct sockaddr_storage *addr,

341 const char *hostname, int port)

342 {

343 struct addrinfo *res0;

344 int addr_len;

345

346 res0 = ff_ip_resolve_host(h, hostname, port, SOCK_DGRAM, AF_UNSPEC, 0);

347 if (!res0) return AVERROR(EIO);

348 memcpy(addr, res0->ai_addr, res0->ai_addrlen);

349 addr_len = res0->ai_addrlen;

350 freeaddrinfo(res0);

351

352 return addr_len;

353 }

354

355 static int udp_socket_create(URLContext *h, struct sockaddr_storage *addr,

356 socklen_t *addr_len, const char *localaddr)

357 {

358 UDPContext *s = h->priv_data;

359 int udp_fd = -1;

360 struct addrinfo *res0, *res;

361 int family = AF_UNSPEC;

362

363 if (((struct sockaddr *) &s->dest_addr)->sa_family)

364 family = ((struct sockaddr *) &s->dest_addr)->sa_family;

365 res0 = ff_ip_resolve_host(h, (localaddr && localaddr[0]) ? localaddr : NULL,

366 s->local_port,

367 SOCK_DGRAM, family, AI_PASSIVE);

368 if (!res0)

369 goto fail;

370 for (res = res0; res; res=res->ai_next) {

371 if (s->udplite_coverage)

372 udp_fd = ff_socket(res->ai_family, SOCK_DGRAM, IPPROTO_UDPLITE, h);

373 else

374 udp_fd = ff_socket(res->ai_family, SOCK_DGRAM, 0, h);

375 if (udp_fd != -1) break;

376 ff_log_net_error(h, AV_LOG_ERROR, "socket");

377 }

378

379 if (udp_fd < 0)

380 goto fail;

381

382 memcpy(addr, res->ai_addr, res->ai_addrlen);

383 *addr_len = res->ai_addrlen;

384

385 freeaddrinfo(res0);

386

387 return udp_fd;

388

389 fail:

390 if (udp_fd >= 0)

391 closesocket(udp_fd);

392 if(res0)

393 freeaddrinfo(res0);

394 return -1;

395 }

396

397 static int udp_port(struct sockaddr_storage *addr, int addr_len)

398 {

399 char sbuf[sizeof(int)*3+1];

400 int error;

401

402 if ((error = getnameinfo((struct sockaddr *)addr, addr_len, NULL, 0, sbuf, sizeof(sbuf), NI_NUMERICSERV)) != 0) {

403 av_log(NULL, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(error));

404 return -1;

405 }

406

407 return strtol(sbuf, NULL, 10);

408 }

409

410

411 /**

412 * If no filename is given to av_open_input_file because you want to

413 * get the local port first, then you must call this function to set

414 * the remote server address.

415 *

416 * url syntax: udp://host:port[?option=val...]

417 * option: 'ttl=n' : set the ttl value (for multicast only)

418 * 'localport=n' : set the local port

419 * 'pkt_size=n' : set max packet size

420 * 'reuse=1' : enable reusing the socket

421 * 'overrun_nonfatal=1': survive in case of circular buffer overrun

422 *

423 * @param h media file context

424 * @param uri of the remote server

425 * @return zero if no error.

426 */

427 int ff_udp_set_remote_url(URLContext *h, const char *uri)

428 {

429 UDPContext *s = h->priv_data;

430 char hostname[256], buf[10];

431 int port;

432 const char *p;

433

434 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);

435

436 /* set the destination address */

437 s->dest_addr_len = udp_set_url(h, &s->dest_addr, hostname, port);

438 if (s->dest_addr_len < 0) {

439 return AVERROR(EIO);

440 }

441 s->is_multicast = ff_is_multicast_address((struct sockaddr*) &s->dest_addr);

442 p = strchr(uri, '?');

443 if (p) {

444 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {

445 int was_connected = s->is_connected;

446 s->is_connected = strtol(buf, NULL, 10);

447 if (s->is_connected && !was_connected) {

448 if (connect(s->udp_fd, (struct sockaddr *) &s->dest_addr,

449 s->dest_addr_len)) {

450 s->is_connected = 0;

451 ff_log_net_error(h, AV_LOG_ERROR, "connect");

452 return AVERROR(EIO);

453 }

454 }

455 }

456 }

457

458 return 0;

459 }

460

461 /**

462 * Return the local port used by the UDP connection

463 * @param h media file context

464 * @return the local port number

465 */

466 int ff_udp_get_local_port(URLContext *h)

467 {

468 UDPContext *s = h->priv_data;

469 return s->local_port;

470 }

471

472 /**

473 * Return the udp file handle for select() usage to wait for several RTP

474 * streams at the same time.

475 * @param h media file context

476 */

477 static int udp_get_file_handle(URLContext *h)

478 {

479 UDPContext *s = h->priv_data;

480 return s->udp_fd;

481 }

482

483 #if HAVE_PTHREAD_CANCEL

484 static void *circular_buffer_task_rx( void *_URLContext)

485 {

486 URLContext *h = _URLContext;

487 UDPContext *s = h->priv_data;

488 int old_cancelstate;

489

490 ff_thread_setname("udp-rx");

491

492 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate);

493 pthread_mutex_lock(&s->mutex);

494 if (ff_socket_nonblock(s->udp_fd, 0) < 0) {

495 av_log(h, AV_LOG_ERROR, "Failed to set blocking mode");

496 s->circular_buffer_error = AVERROR(EIO);

497 goto end;

498 }

499 while(1) {

500 int len;

501 struct sockaddr_storage addr;

502 socklen_t addr_len = sizeof(addr);

503

504 pthread_mutex_unlock(&s->mutex);

505 /* Blocking operations are always cancellation points;

506 see "General Information" / "Thread Cancelation Overview"

507 in Single Unix. */

508 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_cancelstate);

509 len = recvfrom(s->udp_fd, s->tmp+4, sizeof(s->tmp)-4, 0, (struct sockaddr *)&addr, &addr_len);

510 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate);

511 pthread_mutex_lock(&s->mutex);

512 if (len < 0) {

513 if (ff_neterrno() != AVERROR(EAGAIN) && ff_neterrno() != AVERROR(EINTR)) {

514 s->circular_buffer_error = ff_neterrno();

515 goto end;

516 }

517 continue;

518 }

519 if (ff_ip_check_source_lists(&addr, &s->filters))

520 continue;

521 AV_WL32(s->tmp, len);

522

523 if (av_fifo_can_write(s->fifo) < len + 4) {

524 /* No Space left */

525 if (s->overrun_nonfatal) {

526 av_log(h, AV_LOG_WARNING, "Circular buffer overrun. "

527 "Surviving due to overrun_nonfatal option\n");

528 continue;

529 } else {

530 av_log(h, AV_LOG_ERROR, "Circular buffer overrun. "

531 "To avoid, increase fifo_size URL option. "

532 "To survive in such case, use overrun_nonfatal option\n");

533 s->circular_buffer_error = AVERROR(EIO);

534 goto end;

535 }

536 }

537 av_fifo_write(s->fifo, s->tmp, len + 4);

538 pthread_cond_signal(&s->cond);

539 }

540

541 end:

542 pthread_cond_signal(&s->cond);

543 pthread_mutex_unlock(&s->mutex);

544 return NULL;

545 }

546

547 static void *circular_buffer_task_tx( void *_URLContext)

548 {

549 URLContext *h = _URLContext;

550 UDPContext *s = h->priv_data;

551 int64_t target_timestamp = av_gettime_relative();

552 int64_t start_timestamp = av_gettime_relative();

553 int64_t sent_bits = 0;

554 int64_t burst_interval = s->bitrate ? (s->burst_bits * 1000000 / s->bitrate) : 0;

555 int64_t max_delay = s->bitrate ? ((int64_t)h->max_packet_size * 8 * 1000000 / s->bitrate + 1) : 0;

556

557 ff_thread_setname("udp-tx");

558

559 pthread_mutex_lock(&s->mutex);

560

561 if (ff_socket_nonblock(s->udp_fd, 0) < 0) {

562 av_log(h, AV_LOG_ERROR, "Failed to set blocking mode");

563 s->circular_buffer_error = AVERROR(EIO);

564 goto end;

565 }

566

567 for(;;) {

568 int len;

569 const uint8_t *p;

570 uint8_t tmp[4];

571 int64_t timestamp;

572

573 len = av_fifo_can_read(s->fifo);

574

575 while (len<4) {

576 if (s->close_req)

577 goto end;

578 pthread_cond_wait(&s->cond, &s->mutex);

579 len = av_fifo_can_read(s->fifo);

580 }

581

582 av_fifo_read(s->fifo, tmp, 4);

583 len = AV_RL32(tmp);

584

585 av_assert0(len >= 0);

586 av_assert0(len <= sizeof(s->tmp));

587

588 av_fifo_read(s->fifo, s->tmp, len);

589

590 pthread_mutex_unlock(&s->mutex);

591

592 if (s->bitrate) {

593 timestamp = av_gettime_relative();

594 if (timestamp < target_timestamp) {

595 int64_t delay = target_timestamp - timestamp;

596 if (delay > max_delay) {

597 delay = max_delay;

598 start_timestamp = timestamp + delay;

599 sent_bits = 0;

600 }

601 av_usleep(delay);

602 } else {

603 if (timestamp - burst_interval > target_timestamp) {

604 start_timestamp = timestamp - burst_interval;

605 sent_bits = 0;

606 }

607 }

608 sent_bits += len * 8;

609 target_timestamp = start_timestamp + sent_bits * 1000000 / s->bitrate;

610 }

611

612 p = s->tmp;

613 while (len) {

614 int ret;

615 av_assert0(len > 0);

616 if (!s->is_connected) {

617 ret = sendto (s->udp_fd, p, len, 0,

618 (struct sockaddr *) &s->dest_addr,

619 s->dest_addr_len);

620 } else

621 ret = send(s->udp_fd, p, len, 0);

622 if (ret >= 0) {

623 len -= ret;

624 p += ret;

625 } else {

626 ret = ff_neterrno();

627 if (ret != AVERROR(EAGAIN) && ret != AVERROR(EINTR)) {

628 pthread_mutex_lock(&s->mutex);

629 s->circular_buffer_error = ret;

630 pthread_mutex_unlock(&s->mutex);

631 return NULL;

632 }

633 }

634 }

635

636 pthread_mutex_lock(&s->mutex);

637 }

638

639 end:

640 pthread_mutex_unlock(&s->mutex);

641 return NULL;

642 }

643

644

645 #endif

646

647 /* put it in UDP context */

648 /* return non zero if error */

649 static int udp_open(URLContext *h, const char *uri, int flags)

650 {

651 char hostname[1024];

652 int port, udp_fd = -1, tmp, bind_ret = -1, dscp = -1;

653 UDPContext *s = h->priv_data;

654 int is_output;

655 const char *p;

656 char buf[256];

657 struct sockaddr_storage my_addr;

658 socklen_t len;

659 int ret;

660

661 h->is_streamed = 1;

662

663 is_output = !(flags & AVIO_FLAG_READ);

664 if (s->buffer_size < 0)

665 s->buffer_size = is_output ? UDP_TX_BUF_SIZE : UDP_RX_BUF_SIZE;

666

667 if (s->sources) {

668 if ((ret = ff_ip_parse_sources(h, s->sources, &s->filters)) < 0)

669 goto fail;

670 }

671

672 if (s->block) {

673 if ((ret = ff_ip_parse_blocks(h, s->block, &s->filters)) < 0)

674 goto fail;

675 }

676

677 p = strchr(uri, '?');

678 if (p) {

679 if (av_find_info_tag(buf, sizeof(buf), "reuse", p)) {

680 char *endptr = NULL;

681 s->reuse_socket = strtol(buf, &endptr, 10);

682 /* assume if no digits were found it is a request to enable it */

683 if (buf == endptr)

684 s->reuse_socket = 1;

685 }

686 if (av_find_info_tag(buf, sizeof(buf), "overrun_nonfatal", p)) {

687 char *endptr = NULL;

688 s->overrun_nonfatal = strtol(buf, &endptr, 10);

689 /* assume if no digits were found it is a request to enable it */

690 if (buf == endptr)

691 s->overrun_nonfatal = 1;

692 if (!HAVE_PTHREAD_CANCEL)

693 av_log(h, AV_LOG_WARNING,

694 "'overrun_nonfatal' option was set but it is not supported "

695 "on this build (pthread support is required)\n");

696 }

697 if (av_find_info_tag(buf, sizeof(buf), "ttl", p)) {

698 s->ttl = strtol(buf, NULL, 10);

699 if (s->ttl < 0 || s->ttl > 255) {

700 av_log(h, AV_LOG_ERROR, "ttl(%d) should be in range [0,255]\n", s->ttl);

701 ret = AVERROR(EINVAL);

702 goto fail;

703 }

704 }

705 if (av_find_info_tag(buf, sizeof(buf), "udplite_coverage", p)) {

706 s->udplite_coverage = strtol(buf, NULL, 10);

707 }

708 if (av_find_info_tag(buf, sizeof(buf), "localport", p)) {

709 s->local_port = strtol(buf, NULL, 10);

710 }

711 if (av_find_info_tag(buf, sizeof(buf), "pkt_size", p)) {

712 s->pkt_size = strtol(buf, NULL, 10);

713 }

714 if (av_find_info_tag(buf, sizeof(buf), "buffer_size", p)) {

715 s->buffer_size = strtol(buf, NULL, 10);

716 }

717 if (av_find_info_tag(buf, sizeof(buf), "connect", p)) {

718 s->is_connected = strtol(buf, NULL, 10);

719 }

720 if (av_find_info_tag(buf, sizeof(buf), "dscp", p)) {

721 dscp = strtol(buf, NULL, 10);

722 }

723 if (av_find_info_tag(buf, sizeof(buf), "fifo_size", p)) {

724 s->circular_buffer_size = strtol(buf, NULL, 10);

725 if (!HAVE_PTHREAD_CANCEL)

726 av_log(h, AV_LOG_WARNING,

727 "'circular_buffer_size' option was set but it is not supported "

728 "on this build (pthread support is required)\n");

729 }

730 if (av_find_info_tag(buf, sizeof(buf), "bitrate", p)) {

731 s->bitrate = strtoll(buf, NULL, 10);

732 if (!HAVE_PTHREAD_CANCEL)

733 av_log(h, AV_LOG_WARNING,

734 "'bitrate' option was set but it is not supported "

735 "on this build (pthread support is required)\n");

736 }

737 if (av_find_info_tag(buf, sizeof(buf), "burst_bits", p)) {

738 s->burst_bits = strtoll(buf, NULL, 10);

739 }

740 if (av_find_info_tag(buf, sizeof(buf), "localaddr", p)) {

741 av_freep(&s->localaddr);

742 s->localaddr = av_strdup(buf);

743 }

744 if (av_find_info_tag(buf, sizeof(buf), "sources", p)) {

745 if ((ret = ff_ip_parse_sources(h, buf, &s->filters)) < 0)

746 goto fail;

747 }

748 if (av_find_info_tag(buf, sizeof(buf), "block", p)) {

749 if ((ret = ff_ip_parse_blocks(h, buf, &s->filters)) < 0)

750 goto fail;

751 }

752 if (!is_output && av_find_info_tag(buf, sizeof(buf), "timeout", p))

753 s->timeout = strtol(buf, NULL, 10);

754 if (is_output && av_find_info_tag(buf, sizeof(buf), "broadcast", p))

755 s->is_broadcast = strtol(buf, NULL, 10);

756 }

757 /* handling needed to support options picking from both AVOption and URL */

758 s->circular_buffer_size *= 188;

759 if (flags & AVIO_FLAG_WRITE) {

760 h->max_packet_size = s->pkt_size;

761 } else {

762 h->max_packet_size = UDP_MAX_PKT_SIZE;

763 }

764 h->rw_timeout = s->timeout;

765

766 /* fill the dest addr */

767 av_url_split(NULL, 0, NULL, 0, hostname, sizeof(hostname), &port, NULL, 0, uri);

768

769 /* XXX: fix av_url_split */

770 if (hostname[0] == '0円' || hostname[0] == '?') {

771 /* only accepts null hostname if input */

772 if (!(flags & AVIO_FLAG_READ)) {

773 ret = AVERROR(EINVAL);

774 goto fail;

775 }

776 } else {

777 if ((ret = ff_udp_set_remote_url(h, uri)) < 0)

778 goto fail;

779 }

780

781 if ((s->is_multicast || s->local_port <= 0) && (h->flags & AVIO_FLAG_READ))

782 s->local_port = port;

783

784 udp_fd = udp_socket_create(h, &my_addr, &len, s->localaddr);

785 if (udp_fd < 0) {

786 ret = AVERROR(EIO);

787 goto fail;

788 }

789

790 s->local_addr_storage=my_addr; //store for future multicast join

791

792 /* Follow the requested reuse option, unless it's multicast in which

793 * case enable reuse unless explicitly disabled.

794 */

795 if (s->reuse_socket > 0 || (s->is_multicast && s->reuse_socket < 0)) {

796 s->reuse_socket = 1;

797 if (setsockopt (udp_fd, SOL_SOCKET, SO_REUSEADDR, &(s->reuse_socket), sizeof(s->reuse_socket)) != 0) {

798 ret = ff_neterrno();

799 goto fail;

800 }

801 }

802

803 if (s->is_broadcast) {

804 #ifdef SO_BROADCAST

805 if (setsockopt (udp_fd, SOL_SOCKET, SO_BROADCAST, &(s->is_broadcast), sizeof(s->is_broadcast)) != 0) {

806 ret = ff_neterrno();

807 goto fail;

808 }

809 #else

810 ret = AVERROR(ENOSYS);

811 goto fail;

812 #endif

813 }

814

815 /* Set the checksum coverage for UDP-Lite (RFC 3828) for sending and receiving.

816 * The receiver coverage has to be less than or equal to the sender coverage.

817 * Otherwise, the receiver will drop all packets.

818 */

819 if (s->udplite_coverage) {

820 if (setsockopt (udp_fd, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV, &(s->udplite_coverage), sizeof(s->udplite_coverage)) != 0)

821 av_log(h, AV_LOG_WARNING, "socket option UDPLITE_SEND_CSCOV not available");

822

823 if (setsockopt (udp_fd, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV, &(s->udplite_coverage), sizeof(s->udplite_coverage)) != 0)

824 av_log(h, AV_LOG_WARNING, "socket option UDPLITE_RECV_CSCOV not available");

825 }

826

827 if (dscp >= 0) {

828 dscp <<= 2;

829 if (setsockopt (udp_fd, IPPROTO_IP, IP_TOS, &dscp, sizeof(dscp)) != 0) {

830 ret = ff_neterrno();

831 goto fail;

832 }

833 }

834

835 /* If multicast, try binding the multicast address first, to avoid

836 * receiving UDP packets from other sources aimed at the same UDP

837 * port. This fails on windows. This makes sending to the same address

838 * using sendto() fail, so only do it if we're opened in read-only mode. */

839 if (s->is_multicast && (h->flags & AVIO_FLAG_READ)) {

840 bind_ret = bind(udp_fd,(struct sockaddr *)&s->dest_addr, len);

841 }

842 /* bind to the local address if not multicast or if the multicast

843 * bind failed */

844 /* the bind is needed to give a port to the socket now */

845 if (bind_ret < 0 && bind(udp_fd,(struct sockaddr *)&my_addr, len) < 0) {

846 ff_log_net_error(h, AV_LOG_ERROR, "bind failed");

847 ret = ff_neterrno();

848 goto fail;

849 }

850

851 len = sizeof(my_addr);

852 getsockname(udp_fd, (struct sockaddr *)&my_addr, &len);

853 s->local_port = udp_port(&my_addr, len);

854

855 if (s->is_multicast) {

856 if (h->flags & AVIO_FLAG_WRITE) {

857 /* output */

858 if ((ret = udp_set_multicast_ttl(udp_fd, s->ttl, (struct sockaddr *)&s->dest_addr, h)) < 0)

859 goto fail;

860 }

861 if (h->flags & AVIO_FLAG_READ) {

862 /* input */

863 if (s->filters.nb_include_addrs) {

864 if ((ret = udp_set_multicast_sources(h, udp_fd,

865 (struct sockaddr *)&s->dest_addr,

866 s->dest_addr_len, &s->local_addr_storage,

867 s->filters.include_addrs,

868 s->filters.nb_include_addrs, 1)) < 0)

869 goto fail;

870 } else {

871 if ((ret = udp_join_multicast_group(udp_fd, (struct sockaddr *)&s->dest_addr,

872 (struct sockaddr *)&s->local_addr_storage, h)) < 0)

873 goto fail;

874 }

875 if (s->filters.nb_exclude_addrs) {

876 if ((ret = udp_set_multicast_sources(h, udp_fd,

877 (struct sockaddr *)&s->dest_addr,

878 s->dest_addr_len, &s->local_addr_storage,

879 s->filters.exclude_addrs,

880 s->filters.nb_exclude_addrs, 0)) < 0)

881 goto fail;

882 }

883 }

884 }

885

886 if (is_output) {

887 /* limit the tx buf size to limit latency */

888 tmp = s->buffer_size;

889 if (setsockopt(udp_fd, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp)) < 0) {

890 ff_log_net_error(h, AV_LOG_ERROR, "setsockopt(SO_SNDBUF)");

891 ret = ff_neterrno();

892 goto fail;

893 }

894 } else {

895 /* set udp recv buffer size to the requested value (default UDP_RX_BUF_SIZE) */

896 tmp = s->buffer_size;

897 if (setsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, sizeof(tmp)) < 0) {

898 ff_log_net_error(h, AV_LOG_WARNING, "setsockopt(SO_RECVBUF)");

899 }

900 len = sizeof(tmp);

901 if (getsockopt(udp_fd, SOL_SOCKET, SO_RCVBUF, &tmp, &len) < 0) {

902 ff_log_net_error(h, AV_LOG_WARNING, "getsockopt(SO_RCVBUF)");

903 } else {

904 av_log(h, AV_LOG_DEBUG, "end receive buffer size reported is %d\n", tmp);

905 if(tmp < s->buffer_size)

906 av_log(h, AV_LOG_WARNING, "attempted to set receive buffer to size %d but it only ended up set as %d\n", s->buffer_size, tmp);

907 }

908

909 /* make the socket non-blocking */

910 ff_socket_nonblock(udp_fd, 1);

911 }

912 if (s->is_connected) {

913 if (connect(udp_fd, (struct sockaddr *) &s->dest_addr, s->dest_addr_len)) {

914 ff_log_net_error(h, AV_LOG_ERROR, "connect");

915 ret = ff_neterrno();

916 goto fail;

917 }

918 }

919

920 s->udp_fd = udp_fd;

921

922 #if HAVE_PTHREAD_CANCEL

923 /*

924 Create thread in case of:

925 1. Input and circular_buffer_size is set

926 2. Output and bitrate and circular_buffer_size is set

927 */

928

929 if (is_output && s->bitrate && !s->circular_buffer_size) {

930 /* Warn user in case of 'circular_buffer_size' is not set */

931 av_log(h, AV_LOG_WARNING,"'bitrate' option was set but 'circular_buffer_size' is not, but required\n");

932 }

933

934 if ((!is_output && s->circular_buffer_size) || (is_output && s->bitrate && s->circular_buffer_size)) {

935 /* start the task going */

936 s->fifo = av_fifo_alloc2(s->circular_buffer_size, 1, 0);

937 if (!s->fifo) {

938 ret = AVERROR(ENOMEM);

939 goto fail;

940 }

941 ret = pthread_mutex_init(&s->mutex, NULL);

942 if (ret != 0) {

943 av_log(h, AV_LOG_ERROR, "pthread_mutex_init failed : %s\n", strerror(ret));

944 ret = AVERROR(ret);

945 goto fail;

946 }

947 ret = pthread_cond_init(&s->cond, NULL);

948 if (ret != 0) {

949 av_log(h, AV_LOG_ERROR, "pthread_cond_init failed : %s\n", strerror(ret));

950 ret = AVERROR(ret);

951 goto cond_fail;

952 }

953 ret = pthread_create(&s->circular_buffer_thread, NULL, is_output?circular_buffer_task_tx:circular_buffer_task_rx, h);

954 if (ret != 0) {

955 av_log(h, AV_LOG_ERROR, "pthread_create failed : %s\n", strerror(ret));

956 ret = AVERROR(ret);

957 goto thread_fail;

958 }

959 s->thread_started = 1;

960 }

961 #endif

962

963 return 0;

964 #if HAVE_PTHREAD_CANCEL

965 thread_fail:

966 pthread_cond_destroy(&s->cond);

967 cond_fail:

968 pthread_mutex_destroy(&s->mutex);

969 #endif

970 fail:

971 if (udp_fd >= 0)

972 closesocket(udp_fd);

973 av_fifo_freep2(&s->fifo);

974 ff_ip_reset_filters(&s->filters);

975 return ret;

976 }

977

978 static int udplite_open(URLContext *h, const char *uri, int flags)

979 {

980 UDPContext *s = h->priv_data;

981

982 // set default checksum coverage

983 s->udplite_coverage = UDP_HEADER_SIZE;

984

985 return udp_open(h, uri, flags);

986 }

987

988 static int udp_read(URLContext *h, uint8_t *buf, int size)

989 {

990 UDPContext *s = h->priv_data;

991 int ret;

992 struct sockaddr_storage addr;

993 socklen_t addr_len = sizeof(addr);

994 #if HAVE_PTHREAD_CANCEL

995 int avail, nonblock = h->flags & AVIO_FLAG_NONBLOCK;

996

997 if (s->fifo) {

998 pthread_mutex_lock(&s->mutex);

999 do {

1000 avail = av_fifo_can_read(s->fifo);

1001 if (avail) { // >=size) {

1002 uint8_t tmp[4];

1003

1004 av_fifo_read(s->fifo, tmp, 4);

1005 avail = AV_RL32(tmp);

1006 if(avail > size){

1007 av_log(h, AV_LOG_WARNING, "Part of datagram lost due to insufficient buffer size\n");

1008 avail = size;

1009 }

1010

1011 av_fifo_read(s->fifo, buf, avail);

1012 av_fifo_drain2(s->fifo, AV_RL32(tmp) - avail);

1013 pthread_mutex_unlock(&s->mutex);

1014 return avail;

1015 } else if(s->circular_buffer_error){

1016 int err = s->circular_buffer_error;

1017 pthread_mutex_unlock(&s->mutex);

1018 return err;

1019 } else if(nonblock) {

1020 pthread_mutex_unlock(&s->mutex);

1021 return AVERROR(EAGAIN);

1022 } else {

1023 /* FIXME: using the monotonic clock would be better,

1024 but it does not exist on all supported platforms. */

1025 int64_t t = av_gettime() + 100000;

1026 struct timespec tv = { .tv_sec = t / 1000000,

1027 .tv_nsec = (t % 1000000) * 1000 };

1028 int err = pthread_cond_timedwait(&s->cond, &s->mutex, &tv);

1029 if (err) {

1030 pthread_mutex_unlock(&s->mutex);

1031 return AVERROR(err == ETIMEDOUT ? EAGAIN : err);

1032 }

1033 nonblock = 1;

1034 }

1035 } while(1);

1036 }

1037 #endif

1038

1039 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {

1040 ret = ff_network_wait_fd(s->udp_fd, 0);

1041 if (ret < 0)

1042 return ret;

1043 }

1044 ret = recvfrom(s->udp_fd, buf, size, 0, (struct sockaddr *)&addr, &addr_len);

1045 if (ret < 0)

1046 return ff_neterrno();

1047 if (ff_ip_check_source_lists(&addr, &s->filters))

1048 return AVERROR(EINTR);

1049 return ret;

1050 }

1051

1052 static int udp_write(URLContext *h, const uint8_t *buf, int size)

1053 {

1054 UDPContext *s = h->priv_data;

1055 int ret;

1056

1057 #if HAVE_PTHREAD_CANCEL

1058 if (s->fifo) {

1059 uint8_t tmp[4];

1060

1061 pthread_mutex_lock(&s->mutex);

1062

1063 /*

1064 Return error if last tx failed.

1065 Here we can't know on which packet error was, but it needs to know that error exists.

1066 */

1067 if (s->circular_buffer_error<0) {

1068 int err = s->circular_buffer_error;

1069 pthread_mutex_unlock(&s->mutex);

1070 return err;

1071 }

1072

1073 if (av_fifo_can_write(s->fifo) < size + 4) {

1074 /* What about a partial packet tx ? */

1075 pthread_mutex_unlock(&s->mutex);

1076 return AVERROR(ENOMEM);

1077 }

1078 AV_WL32(tmp, size);

1079 av_fifo_write(s->fifo, tmp, 4); /* size of packet */

1080 av_fifo_write(s->fifo, buf, size); /* the data */

1081 pthread_cond_signal(&s->cond);

1082 pthread_mutex_unlock(&s->mutex);

1083 return size;

1084 }

1085 #endif

1086 if (!(h->flags & AVIO_FLAG_NONBLOCK)) {

1087 ret = ff_network_wait_fd(s->udp_fd, 1);

1088 if (ret < 0)

1089 return ret;

1090 }

1091

1092 if (!s->is_connected) {

1093 ret = sendto (s->udp_fd, buf, size, 0,

1094 (struct sockaddr *) &s->dest_addr,

1095 s->dest_addr_len);

1096 } else

1097 ret = send(s->udp_fd, buf, size, 0);

1098

1099 return ret < 0 ? ff_neterrno() : ret;

1100 }

1101

1102 static int udp_close(URLContext *h)

1103 {

1104 UDPContext *s = h->priv_data;

1105

1106 #if HAVE_PTHREAD_CANCEL

1107 // Request close once writing is finished

1108 if (s->thread_started && !(h->flags & AVIO_FLAG_READ)) {

1109 pthread_mutex_lock(&s->mutex);

1110 s->close_req = 1;

1111 pthread_cond_signal(&s->cond);

1112 pthread_mutex_unlock(&s->mutex);

1113 }

1114 #endif

1115

1116 if (s->is_multicast && (h->flags & AVIO_FLAG_READ))

1117 udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr,

1118 (struct sockaddr *)&s->local_addr_storage, h);

1119 #if HAVE_PTHREAD_CANCEL

1120 if (s->thread_started) {

1121 int ret;

1122 // Cancel only read, as write has been signaled as success to the user

1123 if (h->flags & AVIO_FLAG_READ) {

1124 #ifdef _WIN32

1125 /* recvfrom() is not a cancellation point for win32, so we shutdown

1126 * the socket and abort pending IO, subsequent recvfrom() calls

1127 * will fail with WSAESHUTDOWN causing the thread to exit. */

1128 shutdown(s->udp_fd, SD_RECEIVE);

1129 CancelIoEx((HANDLE)(SOCKET)s->udp_fd, NULL);

1130 #else

1131 pthread_cancel(s->circular_buffer_thread);

1132 #endif

1133 }

1134 ret = pthread_join(s->circular_buffer_thread, NULL);

1135 if (ret != 0)

1136 av_log(h, AV_LOG_ERROR, "pthread_join(): %s\n", strerror(ret));

1137 pthread_mutex_destroy(&s->mutex);

1138 pthread_cond_destroy(&s->cond);

1139 }

1140 #endif

1141 closesocket(s->udp_fd);

1142 av_fifo_freep2(&s->fifo);

1143 ff_ip_reset_filters(&s->filters);

1144 return 0;

1145 }

1146

1147 const URLProtocol ff_udp_protocol = {

1148 .name = "udp",

1149 .url_open = udp_open,

1150 .url_read = udp_read,

1151 .url_write = udp_write,

1152 .url_close = udp_close,

1153 .url_get_file_handle = udp_get_file_handle,

1154 .priv_data_size = sizeof(UDPContext),

1155 .priv_data_class = &udp_class,

1156 .flags = URL_PROTOCOL_FLAG_NETWORK,

1157 };

1158

1159 const URLProtocol ff_udplite_protocol = {

1160 .name = "udplite",

1161 .url_open = udplite_open,

1162 .url_read = udp_read,

1163 .url_write = udp_write,

1164 .url_close = udp_close,

1165 .url_get_file_handle = udp_get_file_handle,

1166 .priv_data_size = sizeof(UDPContext),

1167 .priv_data_class = &udplite_context_class,

1168 .flags = URL_PROTOCOL_FLAG_NETWORK,

1169 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

pthread_mutex_t

_fmutex pthread_mutex_t

Definition: os2threads.h:53

PTHREAD_CANCEL_ENABLE

#define PTHREAD_CANCEL_ENABLE

Definition: w32pthreads.h:66

av_fifo_drain2

void av_fifo_drain2(AVFifo *f, size_t size)

Discard the specified amount of data from an AVFifo.

Definition: fifo.c:266

pthread_join

static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)

Definition: os2threads.h:94

av_gettime_relative

int64_t av_gettime_relative(void)

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

Definition: time.c:56

ff_udp_get_local_port

int ff_udp_get_local_port(URLContext *h)

Return the local port used by the UDP connection.

Definition: udp.c:466

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

av_fifo_can_write

size_t av_fifo_can_write(const AVFifo *f)

Definition: fifo.c:94

level

uint8_t level

Definition: svq3.c:204

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

av_find_info_tag

int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)

Attempt to find a specific tag in a URL.

Definition: parseutils.c:753

UDPContext::pkt_size

int pkt_size

Definition: udp.c:89

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:426

UDPContext::is_connected

int is_connected

Definition: udp.c:97

PTHREAD_CANCEL_DISABLE

#define PTHREAD_CANCEL_DISABLE

Definition: w32pthreads.h:67

URL_PROTOCOL_FLAG_NETWORK

#define URL_PROTOCOL_FLAG_NETWORK

Definition: url.h:33

ff_ip_parse_sources

int ff_ip_parse_sources(void *log_ctx, const char *buf, IPSourceFilters *filters)

Parses the address[,address] source list in buf and adds it to the filters in the IPSourceFilters str...

Definition: ip.c:145

udp_socket_create

static int udp_socket_create(URLContext *h, struct sockaddr_storage *addr, socklen_t *addr_len, const char *localaddr)

Definition: udp.c:355

thread.h

#define E

Definition: udp.c:124

pthread_mutex_init

static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)

Definition: os2threads.h:104

IPPROTO_UDPLITE

#define IPPROTO_UDPLITE

Definition: udp.c:61

udp_set_multicast_ttl

static int udp_set_multicast_ttl(int sockfd, int mcastTTL, struct sockaddr *addr, void *logctx)

Definition: udp.c:161

NI_NUMERICSERV

#define NI_NUMERICSERV

Definition: network.h:203

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

OFFSET

#define OFFSET(x)

Definition: udp.c:122

sources

Note except for filters that can have queued frames and sources

Definition: filter_design.txt:285

AVOption

AVOption.

Definition: opt.h:251

ff_log_net_error

void ff_log_net_error(void *ctx, int level, const char *prefix)

Definition: network.c:581

udp_port

static int udp_port(struct sockaddr_storage *addr, int addr_len)

Definition: udp.c:397

ff_udp_set_remote_url

int ff_udp_set_remote_url(URLContext *h, const char *uri)

If no filename is given to av_open_input_file because you want to get the local port first,...

Definition: udp.c:427

UDPLITE_RECV_CSCOV

#define UDPLITE_RECV_CSCOV

Definition: udp.c:57

udplite_context_class

static const AVClass udplite_context_class

Definition: udp.c:154

URLProtocol

Definition: url.h:53

os_support.h

UDPContext::bitrate

int64_t bitrate

Definition: udp.c:103

UDPContext::local_addr_storage

struct sockaddr_storage local_addr_storage

Definition: udp.c:116

UDPContext::is_broadcast

int is_broadcast

Definition: udp.c:91

sockaddr_storage

Definition: network.h:111

UDPContext::is_multicast

int is_multicast

Definition: udp.c:90

freeaddrinfo

#define freeaddrinfo

Definition: network.h:218

fifo.h

ff_ip_reset_filters

void ff_ip_reset_filters(IPSourceFilters *filters)

Resets the IP filter list and frees the internal fields of an IPSourceFilters structure.

Definition: ip.c:155

ff_udp_protocol

const URLProtocol ff_udp_protocol

Definition: udp.c:1147

udp_leave_multicast_group

static int udp_leave_multicast_group(int sockfd, struct sockaddr *addr, struct sockaddr *local_addr, void *logctx)

Definition: udp.c:236

fail

#define fail()

Definition: checkasm.h:134

av_fifo_write

int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)

Write data into a FIFO.

Definition: fifo.c:188

UDPContext::filters

IPSourceFilters filters

Definition: udp.c:119

udp_set_url

static int udp_set_url(URLContext *h, struct sockaddr_storage *addr, const char *hostname, int port)

Definition: udp.c:339

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_fifo_read

int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)

Read data from a FIFO.

Definition: fifo.c:240

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:256

UDPContext::remaining_in_dg

int remaining_in_dg

Definition: udp.c:113

UDPContext::close_req

int close_req

Definition: udp.c:105

AV_OPT_TYPE_INT64

@ AV_OPT_TYPE_INT64

Definition: opt.h:226

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

UDPContext::dest_addr_len

int dest_addr_len

Definition: udp.c:96

AVIO_FLAG_WRITE

#define AVIO_FLAG_WRITE

write-only

Definition: avio.h:624

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

av_usleep

int av_usleep(unsigned usec)

Sleep for a period of time.

Definition: time.c:84

pthread_create

static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)

Definition: os2threads.h:80

UDPContext::reuse_socket

int reuse_socket

Definition: udp.c:93

internal.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

NULL

#define NULL

Definition: coverity.c:32

ff_ip_parse_blocks

int ff_ip_parse_blocks(void *log_ctx, const char *buf, IPSourceFilters *filters)

Parses the address[,address] source block list in buf and adds it to the filters in the IPSourceFilte...

Definition: ip.c:150

UDPContext::circular_buffer_size

int circular_buffer_size

Definition: udp.c:100

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

UDPContext::overrun_nonfatal

int overrun_nonfatal

Definition: udp.c:94

parseutils.h

ff_is_multicast_address

int ff_is_multicast_address(struct sockaddr *addr)

Definition: network.c:145

av_fifo_can_read

size_t av_fifo_can_read(const AVFifo *f)

Definition: fifo.c:87

UDPContext::localaddr

char * localaddr

Definition: udp.c:114

time.h

ff_neterrno

#define ff_neterrno()

Definition: network.h:68

addrinfo::ai_addr

struct sockaddr * ai_addr

Definition: network.h:143

pthread_mutex_unlock

#define pthread_mutex_unlock(a)

Definition: ffprobe.c:79

UDPContext::buffer_size

int buffer_size

Definition: udp.c:88

ff_ip_resolve_host

struct addrinfo * ff_ip_resolve_host(void *log_ctx, const char *hostname, int port, int type, int family, int flags)

Resolves hostname into an addrinfo structure.

Definition: ip.c:65

options

static const AVOption options[]

Definition: udp.c:125

addrinfo::ai_family

int ai_family

Definition: network.h:139

UDPContext::udp_fd

int udp_fd

Definition: udp.c:85

AVFifo

Definition: fifo.c:35

UDPContext::circular_buffer_error

int circular_buffer_error

Definition: udp.c:102

UDPContext

Definition: udp.c:83

size

int size

Definition: twinvq_data.h:10344

UDP_RX_BUF_SIZE

#define UDP_RX_BUF_SIZE

Definition: udp.c:79

URLProtocol::name

const char * name

Definition: url.h:54

UDPContext::burst_bits

int64_t burst_bits

Definition: udp.c:104

ff_socket_nonblock

int ff_socket_nonblock(int socket, int enable)

UDPContext::block

char * block

Definition: udp.c:118

udplite_open

static int udplite_open(URLContext *h, const char *uri, int flags)

Definition: udp.c:978

gai_strerror

#define gai_strerror

Definition: network.h:225

bitrate

int64_t bitrate

Definition: h264_levels.c:131

UDPContext::local_port

int local_port

Definition: udp.c:92

pthread_t

Definition: os2threads.h:44

UDPContext::ttl

int ttl

Definition: udp.c:86

pthread_cond_destroy

static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)

Definition: os2threads.h:144

addrinfo::ai_next

struct addrinfo * ai_next

Definition: network.h:145

addrinfo::ai_addrlen

int ai_addrlen

Definition: network.h:142

pthread_mutex_destroy

static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)

Definition: os2threads.h:112

udp_close

static int udp_close(URLContext *h)

Definition: udp.c:1102

UDP_MAX_PKT_SIZE

#define UDP_MAX_PKT_SIZE

Definition: udp.c:80

URLContext

Definition: url.h:37

log.h

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:269

avio_internal.h

getnameinfo

#define getnameinfo

Definition: network.h:219

ip.h

UDPContext::dest_addr

struct sockaddr_storage dest_addr

Definition: udp.c:95

av_url_split

void av_url_split(char *proto, int proto_size, char *authorization, int authorization_size, char *hostname, int hostname_size, int *port_ptr, char *path, int path_size, const char *url)

Split a URL string into components.

Definition: utils.c:357

udp_join_multicast_group

static int udp_join_multicast_group(int sockfd, struct sockaddr *addr, struct sockaddr *local_addr, void *logctx)

Definition: udp.c:202

url.h

len

int len

Definition: vorbis_enc_data.h:426

pthread_cond_t

Definition: os2threads.h:58

ff_udplite_protocol

const URLProtocol ff_udplite_protocol

Definition: udp.c:1159

pthread_setcancelstate

static int pthread_setcancelstate(int state, int *oldstate)

Definition: w32pthreads.h:186

udp_read

static int udp_read(URLContext *h, uint8_t *buf, int size)

Definition: udp.c:988

udp_set_multicast_sources

static int udp_set_multicast_sources(URLContext *h, int sockfd, struct sockaddr *addr, int addr_len, struct sockaddr_storage *local_addr, struct sockaddr_storage *sources, int nb_sources, int include)

Definition: udp.c:270

ret

Definition: filter_design.txt:187

UDP_TX_BUF_SIZE

#define UDP_TX_BUF_SIZE

Definition: udp.c:78

#define D

Definition: udp.c:123

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

UDPContext::fifo

AVFifo * fifo

Definition: udp.c:101

avformat.h

UDPContext::timeout

int timeout

Definition: udp.c:115

av_fifo_alloc2

AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)

Allocate and initialize an AVFifo with a given element size.

Definition: fifo.c:47

network.h

pthread_cond_signal

static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)

Definition: os2threads.h:152

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

IPSourceFilters

Structure for storing IP (UDP) source filters or block lists.

Definition: ip.h:29

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:225

IPV6_DROP_MEMBERSHIP

#define IPV6_DROP_MEMBERSHIP

Definition: udp.c:75

udp_write

static int udp_write(URLContext *h, const uint8_t *buf, int size)

Definition: udp.c:1052

ff_ip_check_source_lists

int ff_ip_check_source_lists(struct sockaddr_storage *source_addr_ptr, IPSourceFilters *s)

Checks the source address against a given IP source filter.

Definition: ip.c:46

udp_open

static int udp_open(URLContext *h, const char *uri, int flags)

Definition: udp.c:649

pthread_cond_wait

static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)

Definition: os2threads.h:192

av_gettime

int64_t av_gettime(void)

Get the current time in microseconds.

Definition: time.c:39

AVIO_FLAG_READ

#define AVIO_FLAG_READ

read-only

Definition: avio.h:623

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:270

udp_get_file_handle

static int udp_get_file_handle(URLContext *h)

Return the udp file handle for select() usage to wait for several RTP streams at the same time.

Definition: udp.c:477

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Definition: opt.h:244

AVIO_FLAG_NONBLOCK

#define AVIO_FLAG_NONBLOCK

Use non-blocking mode.

Definition: avio.h:642

UDPContext::tmp

uint8_t tmp[UDP_MAX_PKT_SIZE+4]

Definition: udp.c:112

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

UDPContext::sources

char * sources

Definition: udp.c:117

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:561

pthread_cond_timedwait

static av_always_inline int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)

Definition: os2threads.h:170

block

The exact code depends on how similar the blocks are and how related they are to the block

Definition: filter_design.txt:207

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

UDPContext::udplite_coverage

int udplite_coverage

Definition: udp.c:87

av_fifo_freep2

void av_fifo_freep2(AVFifo **f)

Free an AVFifo and reset pointer to NULL.

Definition: fifo.c:286

pthread_cond_init

static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)

Definition: os2threads.h:133

Definition: vp9dsp_template.c:2038

ff_socket

int ff_socket(int af, int type, int proto, void *logctx)

Definition: network.c:183

avstring.h

AV_OPT_TYPE_STRING

@ AV_OPT_TYPE_STRING

Definition: opt.h:229

addrinfo

Definition: network.h:137

IPV6_ADD_MEMBERSHIP

#define IPV6_ADD_MEMBERSHIP

Definition: udp.c:74

int

Definition: ffmpeg_filter.c:156

UDP_HEADER_SIZE

#define UDP_HEADER_SIZE

Definition: udp.c:81

cond

int(* cond)(enum AVPixelFormat pix_fmt)

Definition: pixdesc_query.c:28

udp_class

static const AVClass udp_class

Definition: udp.c:147

mutex

static AVMutex mutex

Definition: log.c:46

AI_PASSIVE

#define AI_PASSIVE

Definition: network.h:179

UDPLITE_SEND_CSCOV

#define UDPLITE_SEND_CSCOV

Definition: udp.c:56

pthread_mutex_lock

#define pthread_mutex_lock(a)

Definition: ffprobe.c:75

ff_thread_setname

static int ff_thread_setname(const char *name)

Definition: thread.h:195

ff_network_wait_fd

int ff_network_wait_fd(int fd, int write)

Definition: network.c:69

Generated on Tue Feb 28 2023 21:34:10 for FFmpeg by doxygen 1.8.17