FFmpeg: libavformat/rtpenc.c Source File

FFmpeg

[フレーム]

libavformat

rtpenc.c

Go to the documentation of this file.

1 /*

2 * RTP output format

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 "avformat.h"

23 #include "mpegts.h"

24 #include "internal.h"

25 #include "libavutil/mathematics.h"

26 #include "libavutil/random_seed.h"

27 #include "libavutil/opt.h"

29 #include "rtpenc.h"

31 static const AVOption options[] = {

32 FF_RTP_FLAG_OPTS(RTPMuxContext, flags),

33 { "payload_type", "Specify RTP payload type", offsetof(RTPMuxContext, payload_type), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 127, AV_OPT_FLAG_ENCODING_PARAM },

34 { "ssrc", "Stream identifier", offsetof(RTPMuxContext, ssrc), AV_OPT_TYPE_INT, { .i64 = 0 }, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

35 { "cname", "CNAME to include in RTCP SR packets", offsetof(RTPMuxContext, cname), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },

36 { "seq", "Starting sequence number", offsetof(RTPMuxContext, seq), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 65535, AV_OPT_FLAG_ENCODING_PARAM },

37 { NULL },

38 };

40 static const AVClass rtp_muxer_class = {

41 .class_name = "RTP muxer",

42 .item_name = av_default_item_name,

43 .option = options,

44 .version = LIBAVUTIL_VERSION_INT,

45 };

47 #define RTCP_SR_SIZE 28

49 static int is_supported(enum AVCodecID id)

50 {

51 switch(id) {

52 case AV_CODEC_ID_H261:

53 case AV_CODEC_ID_H263:

54 case AV_CODEC_ID_H263P:

55 case AV_CODEC_ID_H264:

56 case AV_CODEC_ID_HEVC:

57 case AV_CODEC_ID_MPEG1VIDEO:

58 case AV_CODEC_ID_MPEG2VIDEO:

59 case AV_CODEC_ID_MPEG4:

60 case AV_CODEC_ID_AAC:

61 case AV_CODEC_ID_MP2:

62 case AV_CODEC_ID_MP3:

63 case AV_CODEC_ID_PCM_ALAW:

64 case AV_CODEC_ID_PCM_MULAW:

65 case AV_CODEC_ID_PCM_S8:

66 case AV_CODEC_ID_PCM_S16BE:

67 case AV_CODEC_ID_PCM_S16LE:

68 case AV_CODEC_ID_PCM_U16BE:

69 case AV_CODEC_ID_PCM_U16LE:

70 case AV_CODEC_ID_PCM_U8:

71 case AV_CODEC_ID_MPEG2TS:

72 case AV_CODEC_ID_AMR_NB:

73 case AV_CODEC_ID_AMR_WB:

74 case AV_CODEC_ID_VORBIS:

75 case AV_CODEC_ID_THEORA:

76 case AV_CODEC_ID_VP8:

77 case AV_CODEC_ID_ADPCM_G722:

78 case AV_CODEC_ID_ADPCM_G726:

79 case AV_CODEC_ID_ILBC:

80 case AV_CODEC_ID_MJPEG:

81 case AV_CODEC_ID_SPEEX:

82 case AV_CODEC_ID_OPUS:

83 return 1;

84 default:

85 return 0;

86 }

87 }

89 static int rtp_write_header(AVFormatContext *s1)

90 {

91 RTPMuxContext *s = s1->priv_data;

92 int n, ret = AVERROR(EINVAL);

93 AVStream *st;

95 if (s1->nb_streams != 1) {

96 av_log(s1, AV_LOG_ERROR, "Only one stream supported in the RTP muxer\n");

97 return AVERROR(EINVAL);

98 }

99 st = s1->streams[0];

100 if (!is_supported(st->codec->codec_id)) {

101 av_log(s1, AV_LOG_ERROR, "Unsupported codec %s\n", avcodec_get_name(st->codec->codec_id));

102

103 return -1;

104 }

105

106 if (s->payload_type < 0) {

107 /* Re-validate non-dynamic payload types */

108 if (st->id < RTP_PT_PRIVATE)

109 st->id = ff_rtp_get_payload_type(s1, st->codec, -1);

110

111 s->payload_type = st->id;

112 } else {

113 /* private option takes priority */

114 st->id = s->payload_type;

115 }

116

117 s->base_timestamp = av_get_random_seed();

118 s->timestamp = s->base_timestamp;

119 s->cur_timestamp = 0;

120 if (!s->ssrc)

121 s->ssrc = av_get_random_seed();

122 s->first_packet = 1;

123 s->first_rtcp_ntp_time = ff_ntp_time();

124 if (s1->start_time_realtime != 0 && s1->start_time_realtime != AV_NOPTS_VALUE)

125 /* Round the NTP time to whole milliseconds. */

126 s->first_rtcp_ntp_time = (s1->start_time_realtime / 1000) * 1000 +

127 NTP_OFFSET_US;

128 // Pick a random sequence start number, but in the lower end of the

129 // available range, so that any wraparound doesn't happen immediately.

130 // (Immediate wraparound would be an issue for SRTP.)

131 if (s->seq < 0) {

132 if (s1->flags & AVFMT_FLAG_BITEXACT) {

133 s->seq = 0;

134 } else

135 s->seq = av_get_random_seed() & 0x0fff;

136 } else

137 s->seq &= 0xffff; // Use the given parameter, wrapped to the right interval

138

139 if (s1->packet_size) {

140 if (s1->pb->max_packet_size)

141 s1->packet_size = FFMIN(s1->packet_size,

142 s1->pb->max_packet_size);

143 } else

144 s1->packet_size = s1->pb->max_packet_size;

145 if (s1->packet_size <= 12) {

146 av_log(s1, AV_LOG_ERROR, "Max packet size %d too low\n", s1->packet_size);

147 return AVERROR(EIO);

148 }

149 s->buf = av_malloc(s1->packet_size);

150 if (!s->buf) {

151 return AVERROR(ENOMEM);

152 }

153 s->max_payload_size = s1->packet_size - 12;

154

155 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {

156 avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);

157 } else {

158 avpriv_set_pts_info(st, 32, 1, 90000);

159 }

160 s->buf_ptr = s->buf;

161 switch(st->codec->codec_id) {

162 case AV_CODEC_ID_MP2:

163 case AV_CODEC_ID_MP3:

164 s->buf_ptr = s->buf + 4;

165 avpriv_set_pts_info(st, 32, 1, 90000);

166 break;

167 case AV_CODEC_ID_MPEG1VIDEO:

168 case AV_CODEC_ID_MPEG2VIDEO:

169 break;

170 case AV_CODEC_ID_MPEG2TS:

171 n = s->max_payload_size / TS_PACKET_SIZE;

172 if (n < 1)

173 n = 1;

174 s->max_payload_size = n * TS_PACKET_SIZE;

175 break;

176 case AV_CODEC_ID_H261:

177 if (s1->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

178 av_log(s, AV_LOG_ERROR,

179 "Packetizing H261 is experimental and produces incorrect "

180 "packetization for cases where GOBs don't fit into packets "

181 "(even though most receivers may handle it just fine). "

182 "Please set -f_strict experimental in order to enable it.\n");

183 ret = AVERROR_EXPERIMENTAL;

184 goto fail;

185 }

186 break;

187 case AV_CODEC_ID_H264:

188 /* check for H.264 MP4 syntax */

189 if (st->codec->extradata_size > 4 && st->codec->extradata[0] == 1) {

190 s->nal_length_size = (st->codec->extradata[4] & 0x03) + 1;

191 }

192 break;

193 case AV_CODEC_ID_HEVC:

194 /* Only check for the standardized hvcC version of extradata, keeping

195 * things simple and similar to the avcC/H264 case above, instead

196 * of trying to handle the pre-standardization versions (as in

197 * libavcodec/hevc.c). */

198 if (st->codec->extradata_size > 21 && st->codec->extradata[0] == 1) {

199 s->nal_length_size = (st->codec->extradata[21] & 0x03) + 1;

200 }

201 break;

202 case AV_CODEC_ID_VORBIS:

203 case AV_CODEC_ID_THEORA:

204 s->max_frames_per_packet = 15;

205 break;

206 case AV_CODEC_ID_ADPCM_G722:

207 /* Due to a historical error, the clock rate for G722 in RTP is

208 * 8000, even if the sample rate is 16000. See RFC 3551. */

209 avpriv_set_pts_info(st, 32, 1, 8000);

210 break;

211 case AV_CODEC_ID_OPUS:

212 if (st->codec->channels > 2) {

213 av_log(s1, AV_LOG_ERROR, "Multistream opus not supported in RTP\n");

214 goto fail;

215 }

216 /* The opus RTP RFC says that all opus streams should use 48000 Hz

217 * as clock rate, since all opus sample rates can be expressed in

218 * this clock rate, and sample rate changes on the fly are supported. */

219 avpriv_set_pts_info(st, 32, 1, 48000);

220 break;

221 case AV_CODEC_ID_ILBC:

222 if (st->codec->block_align != 38 && st->codec->block_align != 50) {

223 av_log(s1, AV_LOG_ERROR, "Incorrect iLBC block size specified\n");

224 goto fail;

225 }

226 s->max_frames_per_packet = s->max_payload_size / st->codec->block_align;

227 break;

228 case AV_CODEC_ID_AMR_NB:

229 case AV_CODEC_ID_AMR_WB:

230 s->max_frames_per_packet = 50;

231 if (st->codec->codec_id == AV_CODEC_ID_AMR_NB)

232 n = 31;

233 else

234 n = 61;

235 /* max_header_toc_size + the largest AMR payload must fit */

236 if (1 + s->max_frames_per_packet + n > s->max_payload_size) {

237 av_log(s1, AV_LOG_ERROR, "RTP max payload size too small for AMR\n");

238 goto fail;

239 }

240 if (st->codec->channels != 1) {

241 av_log(s1, AV_LOG_ERROR, "Only mono is supported\n");

242 goto fail;

243 }

244 break;

245 case AV_CODEC_ID_AAC:

246 s->max_frames_per_packet = 50;

247 break;

248 default:

249 break;

250 }

251

252 return 0;

253

254 fail:

255 av_freep(&s->buf);

256 return ret;

257 }

258

259 /* send an rtcp sender report packet */

260 static void rtcp_send_sr(AVFormatContext *s1, int64_t ntp_time, int bye)

261 {

262 RTPMuxContext *s = s1->priv_data;

263 uint32_t rtp_ts;

264

265 av_dlog(s1, "RTCP: %02x %"PRIx64" %x\n", s->payload_type, ntp_time, s->timestamp);

266

267 s->last_rtcp_ntp_time = ntp_time;

268 rtp_ts = av_rescale_q(ntp_time - s->first_rtcp_ntp_time, (AVRational){1, 1000000},

269 s1->streams[0]->time_base) + s->base_timestamp;

270 avio_w8(s1->pb, RTP_VERSION << 6);

271 avio_w8(s1->pb, RTCP_SR);

272 avio_wb16(s1->pb, 6); /* length in words - 1 */

273 avio_wb32(s1->pb, s->ssrc);

274 avio_wb64(s1->pb, NTP_TO_RTP_FORMAT(ntp_time));

275 avio_wb32(s1->pb, rtp_ts);

276 avio_wb32(s1->pb, s->packet_count);

277 avio_wb32(s1->pb, s->octet_count);

278

279 if (s->cname) {

280 int len = FFMIN(strlen(s->cname), 255);

281 avio_w8(s1->pb, (RTP_VERSION << 6) + 1);

282 avio_w8(s1->pb, RTCP_SDES);

283 avio_wb16(s1->pb, (7 + len + 3) / 4); /* length in words - 1 */

284

285 avio_wb32(s1->pb, s->ssrc);

286 avio_w8(s1->pb, 0x01); /* CNAME */

287 avio_w8(s1->pb, len);

288 avio_write(s1->pb, s->cname, len);

289 avio_w8(s1->pb, 0); /* END */

290 for (len = (7 + len) % 4; len % 4; len++)

291 avio_w8(s1->pb, 0);

292 }

293

294 if (bye) {

295 avio_w8(s1->pb, (RTP_VERSION << 6) | 1);

296 avio_w8(s1->pb, RTCP_BYE);

297 avio_wb16(s1->pb, 1); /* length in words - 1 */

298 avio_wb32(s1->pb, s->ssrc);

299 }

300

301 avio_flush(s1->pb);

302 }

303

304 /* send an rtp packet. sequence number is incremented, but the caller

305 must update the timestamp itself */

306 void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m)

307 {

308 RTPMuxContext *s = s1->priv_data;

309

310 av_dlog(s1, "rtp_send_data size=%d\n", len);

311

312 /* build the RTP header */

313 avio_w8(s1->pb, RTP_VERSION << 6);

314 avio_w8(s1->pb, (s->payload_type & 0x7f) | ((m & 0x01) << 7));

315 avio_wb16(s1->pb, s->seq);

316 avio_wb32(s1->pb, s->timestamp);

317 avio_wb32(s1->pb, s->ssrc);

318

319 avio_write(s1->pb, buf1, len);

320 avio_flush(s1->pb);

321

322 s->seq = (s->seq + 1) & 0xffff;

323 s->octet_count += len;

324 s->packet_count++;

325 }

326

327 /* send an integer number of samples and compute time stamp and fill

328 the rtp send buffer before sending. */

329 static int rtp_send_samples(AVFormatContext *s1,

330 const uint8_t *buf1, int size, int sample_size_bits)

331 {

332 RTPMuxContext *s = s1->priv_data;

333 int len, max_packet_size, n;

334 /* Calculate the number of bytes to get samples aligned on a byte border */

335 int aligned_samples_size = sample_size_bits/av_gcd(sample_size_bits, 8);

336

337 max_packet_size = (s->max_payload_size / aligned_samples_size) * aligned_samples_size;

338 /* Not needed, but who knows. Don't check if samples aren't an even number of bytes. */

339 if ((sample_size_bits % 8) == 0 && ((8 * size) % sample_size_bits) != 0)

340 return AVERROR(EINVAL);

341 n = 0;

342 while (size > 0) {

343 s->buf_ptr = s->buf;

344 len = FFMIN(max_packet_size, size);

345

346 /* copy data */

347 memcpy(s->buf_ptr, buf1, len);

348 s->buf_ptr += len;

349 buf1 += len;

350 size -= len;

351 s->timestamp = s->cur_timestamp + n * 8 / sample_size_bits;

352 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);

353 n += (s->buf_ptr - s->buf);

354 }

355 return 0;

356 }

357

358 static void rtp_send_mpegaudio(AVFormatContext *s1,

359 const uint8_t *buf1, int size)

360 {

361 RTPMuxContext *s = s1->priv_data;

362 int len, count, max_packet_size;

363

364 max_packet_size = s->max_payload_size;

365

366 /* test if we must flush because not enough space */

367 len = (s->buf_ptr - s->buf);

368 if ((len + size) > max_packet_size) {

369 if (len > 4) {

370 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 0);

371 s->buf_ptr = s->buf + 4;

372 }

373 }

374 if (s->buf_ptr == s->buf + 4) {

375 s->timestamp = s->cur_timestamp;

376 }

377

378 /* add the packet */

379 if (size > max_packet_size) {

380 /* big packet: fragment */

381 count = 0;

382 while (size > 0) {

383 len = max_packet_size - 4;

384 if (len > size)

385 len = size;

386 /* build fragmented packet */

387 s->buf[0] = 0;

388 s->buf[1] = 0;

389 s->buf[2] = count >> 8;

390 s->buf[3] = count;

391 memcpy(s->buf + 4, buf1, len);

392 ff_rtp_send_data(s1, s->buf, len + 4, 0);

393 size -= len;

394 buf1 += len;

395 count += len;

396 }

397 } else {

398 if (s->buf_ptr == s->buf + 4) {

399 /* no fragmentation possible */

400 s->buf[0] = 0;

401 s->buf[1] = 0;

402 s->buf[2] = 0;

403 s->buf[3] = 0;

404 }

405 memcpy(s->buf_ptr, buf1, size);

406 s->buf_ptr += size;

407 }

408 }

409

410 static void rtp_send_raw(AVFormatContext *s1,

411 const uint8_t *buf1, int size)

412 {

413 RTPMuxContext *s = s1->priv_data;

414 int len, max_packet_size;

415

416 max_packet_size = s->max_payload_size;

417

418 while (size > 0) {

419 len = max_packet_size;

420 if (len > size)

421 len = size;

422

423 s->timestamp = s->cur_timestamp;

424 ff_rtp_send_data(s1, buf1, len, (len == size));

425

426 buf1 += len;

427 size -= len;

428 }

429 }

430

431 /* NOTE: size is assumed to be an integer multiple of TS_PACKET_SIZE */

432 static void rtp_send_mpegts_raw(AVFormatContext *s1,

433 const uint8_t *buf1, int size)

434 {

435 RTPMuxContext *s = s1->priv_data;

436 int len, out_len;

437

438 s->timestamp = s->cur_timestamp;

439 while (size >= TS_PACKET_SIZE) {

440 len = s->max_payload_size - (s->buf_ptr - s->buf);

441 if (len > size)

442 len = size;

443 memcpy(s->buf_ptr, buf1, len);

444 buf1 += len;

445 size -= len;

446 s->buf_ptr += len;

447

448 out_len = s->buf_ptr - s->buf;

449 if (out_len >= s->max_payload_size) {

450 ff_rtp_send_data(s1, s->buf, out_len, 0);

451 s->buf_ptr = s->buf;

452 }

453 }

454 }

455

456 static int rtp_send_ilbc(AVFormatContext *s1, const uint8_t *buf, int size)

457 {

458 RTPMuxContext *s = s1->priv_data;

459 AVStream *st = s1->streams[0];

460 int frame_duration = av_get_audio_frame_duration(st->codec, 0);

461 int frame_size = st->codec->block_align;

462 int frames = size / frame_size;

463

464 while (frames > 0) {

465 if (s->num_frames > 0 &&

466 av_compare_ts(s->cur_timestamp - s->timestamp, st->time_base,

467 s1->max_delay, AV_TIME_BASE_Q) >= 0) {

468 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);

469 s->num_frames = 0;

470 }

471

472 if (!s->num_frames) {

473 s->buf_ptr = s->buf;

474 s->timestamp = s->cur_timestamp;

475 }

476 memcpy(s->buf_ptr, buf, frame_size);

477 frames--;

478 s->num_frames++;

479 s->buf_ptr += frame_size;

480 buf += frame_size;

481 s->cur_timestamp += frame_duration;

482

483 if (s->num_frames == s->max_frames_per_packet) {

484 ff_rtp_send_data(s1, s->buf, s->buf_ptr - s->buf, 1);

485 s->num_frames = 0;

486 }

487 }

488 return 0;

489 }

490

491 static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)

492 {

493 RTPMuxContext *s = s1->priv_data;

494 AVStream *st = s1->streams[0];

495 int rtcp_bytes;

496 int size= pkt->size;

497

498 av_dlog(s1, "%d: write len=%d\n", pkt->stream_index, size);

499

500 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /

501 RTCP_TX_RATIO_DEN;

502 if ((s->first_packet || ((rtcp_bytes >= RTCP_SR_SIZE) &&

503 (ff_ntp_time() - s->last_rtcp_ntp_time > 5000000))) &&

504 !(s->flags & FF_RTP_FLAG_SKIP_RTCP)) {

505 rtcp_send_sr(s1, ff_ntp_time(), 0);

506 s->last_octet_count = s->octet_count;

507 s->first_packet = 0;

508 }

509 s->cur_timestamp = s->base_timestamp + pkt->pts;

510

511 switch(st->codec->codec_id) {

512 case AV_CODEC_ID_PCM_MULAW:

513 case AV_CODEC_ID_PCM_ALAW:

514 case AV_CODEC_ID_PCM_U8:

515 case AV_CODEC_ID_PCM_S8:

516 return rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);

517 case AV_CODEC_ID_PCM_U16BE:

518 case AV_CODEC_ID_PCM_U16LE:

519 case AV_CODEC_ID_PCM_S16BE:

520 case AV_CODEC_ID_PCM_S16LE:

521 return rtp_send_samples(s1, pkt->data, size, 16 * st->codec->channels);

522 case AV_CODEC_ID_ADPCM_G722:

523 /* The actual sample size is half a byte per sample, but since the

524 * stream clock rate is 8000 Hz while the sample rate is 16000 Hz,

525 * the correct parameter for send_samples_bits is 8 bits per stream

526 * clock. */

527 return rtp_send_samples(s1, pkt->data, size, 8 * st->codec->channels);

528 case AV_CODEC_ID_ADPCM_G726:

529 return rtp_send_samples(s1, pkt->data, size,

530 st->codec->bits_per_coded_sample * st->codec->channels);

531 case AV_CODEC_ID_MP2:

532 case AV_CODEC_ID_MP3:

533 rtp_send_mpegaudio(s1, pkt->data, size);

534 break;

535 case AV_CODEC_ID_MPEG1VIDEO:

536 case AV_CODEC_ID_MPEG2VIDEO:

537 ff_rtp_send_mpegvideo(s1, pkt->data, size);

538 break;

539 case AV_CODEC_ID_AAC:

540 if (s->flags & FF_RTP_FLAG_MP4A_LATM)

541 ff_rtp_send_latm(s1, pkt->data, size);

542 else

543 ff_rtp_send_aac(s1, pkt->data, size);

544 break;

545 case AV_CODEC_ID_AMR_NB:

546 case AV_CODEC_ID_AMR_WB:

547 ff_rtp_send_amr(s1, pkt->data, size);

548 break;

549 case AV_CODEC_ID_MPEG2TS:

550 rtp_send_mpegts_raw(s1, pkt->data, size);

551 break;

552 case AV_CODEC_ID_H264:

553 ff_rtp_send_h264_hevc(s1, pkt->data, size);

554 break;

555 case AV_CODEC_ID_H261:

556 ff_rtp_send_h261(s1, pkt->data, size);

557 break;

558 case AV_CODEC_ID_H263:

559 if (s->flags & FF_RTP_FLAG_RFC2190) {

560 int mb_info_size = 0;

561 const uint8_t *mb_info =

562 av_packet_get_side_data(pkt, AV_PKT_DATA_H263_MB_INFO,

563 &mb_info_size);

564 if (!mb_info) {

565 av_log(s1, AV_LOG_ERROR, "failed to allocate side data\n");

566 return AVERROR(ENOMEM);

567 }

568 ff_rtp_send_h263_rfc2190(s1, pkt->data, size, mb_info, mb_info_size);

569 break;

570 }

571 /* Fallthrough */

572 case AV_CODEC_ID_H263P:

573 ff_rtp_send_h263(s1, pkt->data, size);

574 break;

575 case AV_CODEC_ID_HEVC:

576 ff_rtp_send_h264_hevc(s1, pkt->data, size);

577 break;

578 case AV_CODEC_ID_VORBIS:

579 case AV_CODEC_ID_THEORA:

580 ff_rtp_send_xiph(s1, pkt->data, size);

581 break;

582 case AV_CODEC_ID_VP8:

583 ff_rtp_send_vp8(s1, pkt->data, size);

584 break;

585 case AV_CODEC_ID_ILBC:

586 rtp_send_ilbc(s1, pkt->data, size);

587 break;

588 case AV_CODEC_ID_MJPEG:

589 ff_rtp_send_jpeg(s1, pkt->data, size);

590 break;

591 case AV_CODEC_ID_OPUS:

592 if (size > s->max_payload_size) {

593 av_log(s1, AV_LOG_ERROR,

594 "Packet size %d too large for max RTP payload size %d\n",

595 size, s->max_payload_size);

596 return AVERROR(EINVAL);

597 }

598 /* Intentional fallthrough */

599 default:

600 /* better than nothing : send the codec raw data */

601 rtp_send_raw(s1, pkt->data, size);

602 break;

603 }

604 return 0;

605 }

606

607 static int rtp_write_trailer(AVFormatContext *s1)

608 {

609 RTPMuxContext *s = s1->priv_data;

610

611 /* If the caller closes and recreates ->pb, this might actually

612 * be NULL here even if it was successfully allocated at the start. */

613 if (s1->pb && (s->flags & FF_RTP_FLAG_SEND_BYE))

614 rtcp_send_sr(s1, ff_ntp_time(), 1);

615 av_freep(&s->buf);

616

617 return 0;

618 }

619

620 AVOutputFormat ff_rtp_muxer = {

621 .name = "rtp",

622 .long_name = NULL_IF_CONFIG_SMALL("RTP output"),

623 .priv_data_size = sizeof(RTPMuxContext),

624 .audio_codec = AV_CODEC_ID_PCM_MULAW,

625 .video_codec = AV_CODEC_ID_MPEG4,

626 .write_header = rtp_write_header,

627 .write_packet = rtp_write_packet,

628 .write_trailer = rtp_write_trailer,

629 .priv_class = &rtp_muxer_class,

630 .flags = AVFMT_TS_NONSTRICT,

631 };

Generated on Sun Mar 8 2015 02:35:12 for FFmpeg by doxygen 1.8.2