00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #define _XOPEN_SOURCE 600
00024
00025 #include "libavcodec/get_bits.h"
00026 #include "avformat.h"
00027 #include "mpegts.h"
00028
00029 #include <unistd.h>
00030 #include "network.h"
00031
00032 #include "rtpdec.h"
00033 #include "rtpdec_amr.h"
00034 #include "rtpdec_asf.h"
00035 #include "rtpdec_h263.h"
00036 #include "rtpdec_h264.h"
00037 #include "rtpdec_xiph.h"
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051 RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler= NULL;
00052
00053 static RTPDynamicProtocolHandler mp4v_es_handler= {"MP4V-ES", AVMEDIA_TYPE_VIDEO, CODEC_ID_MPEG4};
00054 static RTPDynamicProtocolHandler mpeg4_generic_handler= {"mpeg4-generic", AVMEDIA_TYPE_AUDIO, CODEC_ID_AAC};
00055
00056 void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler)
00057 {
00058 handler->next= RTPFirstDynamicPayloadHandler;
00059 RTPFirstDynamicPayloadHandler= handler;
00060 }
00061
00062 void av_register_rtp_dynamic_payload_handlers(void)
00063 {
00064 ff_register_dynamic_payload_handler(&mp4v_es_handler);
00065 ff_register_dynamic_payload_handler(&mpeg4_generic_handler);
00066 ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler);
00067 ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler);
00068 ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler);
00069 ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler);
00070 ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
00071 ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
00072 ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
00073
00074 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
00075 ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
00076 }
00077
00078 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
00079 {
00080 if (buf[1] != 200)
00081 return -1;
00082 s->last_rtcp_ntp_time = AV_RB64(buf + 8);
00083 s->last_rtcp_timestamp = AV_RB32(buf + 16);
00084 return 0;
00085 }
00086
00087 #define RTP_SEQ_MOD (1<<16)
00088
00092 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence)
00093 {
00094 memset(s, 0, sizeof(RTPStatistics));
00095 s->max_seq= base_sequence;
00096 s->probation= 1;
00097 }
00098
00102 static void rtp_init_sequence(RTPStatistics *s, uint16_t seq)
00103 {
00104 s->max_seq= seq;
00105 s->cycles= 0;
00106 s->base_seq= seq -1;
00107 s->bad_seq= RTP_SEQ_MOD + 1;
00108 s->received= 0;
00109 s->expected_prior= 0;
00110 s->received_prior= 0;
00111 s->jitter= 0;
00112 s->transit= 0;
00113 }
00114
00118 static int rtp_valid_packet_in_sequence(RTPStatistics *s, uint16_t seq)
00119 {
00120 uint16_t udelta= seq - s->max_seq;
00121 const int MAX_DROPOUT= 3000;
00122 const int MAX_MISORDER = 100;
00123 const int MIN_SEQUENTIAL = 2;
00124
00125
00126 if(s->probation)
00127 {
00128 if(seq==s->max_seq + 1) {
00129 s->probation--;
00130 s->max_seq= seq;
00131 if(s->probation==0) {
00132 rtp_init_sequence(s, seq);
00133 s->received++;
00134 return 1;
00135 }
00136 } else {
00137 s->probation= MIN_SEQUENTIAL - 1;
00138 s->max_seq = seq;
00139 }
00140 } else if (udelta < MAX_DROPOUT) {
00141
00142 if(seq < s->max_seq) {
00143
00144 s->cycles += RTP_SEQ_MOD;
00145 }
00146 s->max_seq= seq;
00147 } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
00148
00149 if(seq==s->bad_seq) {
00150
00151 rtp_init_sequence(s, seq);
00152 } else {
00153 s->bad_seq= (seq + 1) & (RTP_SEQ_MOD-1);
00154 return 0;
00155 }
00156 } else {
00157
00158 }
00159 s->received++;
00160 return 1;
00161 }
00162
00163 #if 0
00164
00169 static void rtcp_update_jitter(RTPStatistics *s, uint32_t sent_timestamp, uint32_t arrival_timestamp)
00170 {
00171 uint32_t transit= arrival_timestamp - sent_timestamp;
00172 int d;
00173 s->transit= transit;
00174 d= FFABS(transit - s->transit);
00175 s->jitter += d - ((s->jitter + 8)>>4);
00176 }
00177 #endif
00178
00179 int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count)
00180 {
00181 ByteIOContext *pb;
00182 uint8_t *buf;
00183 int len;
00184 int rtcp_bytes;
00185 RTPStatistics *stats= &s->statistics;
00186 uint32_t lost;
00187 uint32_t extended_max;
00188 uint32_t expected_interval;
00189 uint32_t received_interval;
00190 uint32_t lost_interval;
00191 uint32_t expected;
00192 uint32_t fraction;
00193 uint64_t ntp_time= s->last_rtcp_ntp_time;
00194
00195 if (!s->rtp_ctx || (count < 1))
00196 return -1;
00197
00198
00199
00200 s->octet_count += count;
00201 rtcp_bytes = ((s->octet_count - s->last_octet_count) * RTCP_TX_RATIO_NUM) /
00202 RTCP_TX_RATIO_DEN;
00203 rtcp_bytes /= 50;
00204 if (rtcp_bytes < 28)
00205 return -1;
00206 s->last_octet_count = s->octet_count;
00207
00208 if (url_open_dyn_buf(&pb) < 0)
00209 return -1;
00210
00211
00212 put_byte(pb, (RTP_VERSION << 6) + 1);
00213 put_byte(pb, 201);
00214 put_be16(pb, 7);
00215 put_be32(pb, s->ssrc);
00216 put_be32(pb, s->ssrc);
00217
00218
00219 extended_max= stats->cycles + stats->max_seq;
00220 expected= extended_max - stats->base_seq + 1;
00221 lost= expected - stats->received;
00222 lost= FFMIN(lost, 0xffffff);
00223 expected_interval= expected - stats->expected_prior;
00224 stats->expected_prior= expected;
00225 received_interval= stats->received - stats->received_prior;
00226 stats->received_prior= stats->received;
00227 lost_interval= expected_interval - received_interval;
00228 if (expected_interval==0 || lost_interval<=0) fraction= 0;
00229 else fraction = (lost_interval<<8)/expected_interval;
00230
00231 fraction= (fraction<<24) | lost;
00232
00233 put_be32(pb, fraction);
00234 put_be32(pb, extended_max);
00235 put_be32(pb, stats->jitter>>4);
00236
00237 if(s->last_rtcp_ntp_time==AV_NOPTS_VALUE)
00238 {
00239 put_be32(pb, 0);
00240 put_be32(pb, 0);
00241 } else {
00242 uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16;
00243 uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
00244
00245 put_be32(pb, middle_32_bits);
00246 put_be32(pb, delay_since_last);
00247 }
00248
00249
00250 put_byte(pb, (RTP_VERSION << 6) + 1);
00251 put_byte(pb, 202);
00252 len = strlen(s->hostname);
00253 put_be16(pb, (6 + len + 3) / 4);
00254 put_be32(pb, s->ssrc);
00255 put_byte(pb, 0x01);
00256 put_byte(pb, len);
00257 put_buffer(pb, s->hostname, len);
00258
00259 for (len = (6 + len) % 4; len % 4; len++) {
00260 put_byte(pb, 0);
00261 }
00262
00263 put_flush_packet(pb);
00264 len = url_close_dyn_buf(pb, &buf);
00265 if ((len > 0) && buf) {
00266 int result;
00267 dprintf(s->ic, "sending %d bytes of RR\n", len);
00268 result= url_write(s->rtp_ctx, buf, len);
00269 dprintf(s->ic, "result from url_write: %d\n", result);
00270 av_free(buf);
00271 }
00272 return 0;
00273 }
00274
00275 void rtp_send_punch_packets(URLContext* rtp_handle)
00276 {
00277 ByteIOContext *pb;
00278 uint8_t *buf;
00279 int len;
00280
00281
00282 if (url_open_dyn_buf(&pb) < 0)
00283 return;
00284
00285 put_byte(pb, (RTP_VERSION << 6));
00286 put_byte(pb, 0);
00287 put_be16(pb, 0);
00288 put_be32(pb, 0);
00289 put_be32(pb, 0);
00290
00291 put_flush_packet(pb);
00292 len = url_close_dyn_buf(pb, &buf);
00293 if ((len > 0) && buf)
00294 url_write(rtp_handle, buf, len);
00295 av_free(buf);
00296
00297
00298 if (url_open_dyn_buf(&pb) < 0)
00299 return;
00300
00301 put_byte(pb, (RTP_VERSION << 6));
00302 put_byte(pb, 201);
00303 put_be16(pb, 1);
00304 put_be32(pb, 0);
00305
00306 put_flush_packet(pb);
00307 len = url_close_dyn_buf(pb, &buf);
00308 if ((len > 0) && buf)
00309 url_write(rtp_handle, buf, len);
00310 av_free(buf);
00311 }
00312
00313
00320 RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data)
00321 {
00322 RTPDemuxContext *s;
00323
00324 s = av_mallocz(sizeof(RTPDemuxContext));
00325 if (!s)
00326 return NULL;
00327 s->payload_type = payload_type;
00328 s->last_rtcp_ntp_time = AV_NOPTS_VALUE;
00329 s->ic = s1;
00330 s->st = st;
00331 s->rtp_payload_data = rtp_payload_data;
00332 rtp_init_statistics(&s->statistics, 0);
00333 if (!strcmp(ff_rtp_enc_name(payload_type), "MP2T")) {
00334 s->ts = ff_mpegts_parse_open(s->ic);
00335 if (s->ts == NULL) {
00336 av_free(s);
00337 return NULL;
00338 }
00339 } else {
00340 av_set_pts_info(st, 32, 1, 90000);
00341 switch(st->codec->codec_id) {
00342 case CODEC_ID_MPEG1VIDEO:
00343 case CODEC_ID_MPEG2VIDEO:
00344 case CODEC_ID_MP2:
00345 case CODEC_ID_MP3:
00346 case CODEC_ID_MPEG4:
00347 case CODEC_ID_H263:
00348 case CODEC_ID_H264:
00349 st->need_parsing = AVSTREAM_PARSE_FULL;
00350 break;
00351 default:
00352 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
00353 av_set_pts_info(st, 32, 1, st->codec->sample_rate);
00354 }
00355 break;
00356 }
00357 }
00358
00359 s->rtp_ctx = rtpc;
00360 gethostname(s->hostname, sizeof(s->hostname));
00361 return s;
00362 }
00363
00364 void
00365 rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
00366 RTPDynamicProtocolHandler *handler)
00367 {
00368 s->dynamic_protocol_context = ctx;
00369 s->parse_packet = handler->parse_packet;
00370 }
00371
00372 static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
00373 {
00374 int au_headers_length, au_header_size, i;
00375 GetBitContext getbitcontext;
00376 RTPPayloadData *infos;
00377
00378 infos = s->rtp_payload_data;
00379
00380 if (infos == NULL)
00381 return -1;
00382
00383
00384
00385 au_headers_length = AV_RB16(buf);
00386
00387 if (au_headers_length > RTP_MAX_PACKET_LENGTH)
00388 return -1;
00389
00390 infos->au_headers_length_bytes = (au_headers_length + 7) / 8;
00391
00392
00393 buf += 2;
00394
00395 init_get_bits(&getbitcontext, buf, infos->au_headers_length_bytes * 8);
00396
00397
00398 au_header_size = infos->sizelength + infos->indexlength;
00399 if (au_header_size <= 0 || (au_headers_length % au_header_size != 0))
00400 return -1;
00401
00402 infos->nb_au_headers = au_headers_length / au_header_size;
00403 if (!infos->au_headers || infos->au_headers_allocated < infos->nb_au_headers) {
00404 av_free(infos->au_headers);
00405 infos->au_headers = av_malloc(sizeof(struct AUHeaders) * infos->nb_au_headers);
00406 infos->au_headers_allocated = infos->nb_au_headers;
00407 }
00408
00409
00410
00411
00412 infos->au_headers[0].size = 0;
00413 infos->au_headers[0].index = 0;
00414 for (i = 0; i < infos->nb_au_headers; ++i) {
00415 infos->au_headers[0].size += get_bits_long(&getbitcontext, infos->sizelength);
00416 infos->au_headers[0].index = get_bits_long(&getbitcontext, infos->indexlength);
00417 }
00418
00419 infos->nb_au_headers = 1;
00420
00421 return 0;
00422 }
00423
00427 static void finalize_packet(RTPDemuxContext *s, AVPacket *pkt, uint32_t timestamp)
00428 {
00429 if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
00430 int64_t addend;
00431 int delta_timestamp;
00432
00433
00434 delta_timestamp = timestamp - s->last_rtcp_timestamp;
00435
00436 addend = av_rescale(s->last_rtcp_ntp_time, s->st->time_base.den, (uint64_t)s->st->time_base.num << 32);
00437 pkt->pts = addend + delta_timestamp;
00438 }
00439 }
00440
00450 int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
00451 const uint8_t *buf, int len)
00452 {
00453 unsigned int ssrc, h;
00454 int payload_type, seq, ret, flags = 0;
00455 AVStream *st;
00456 uint32_t timestamp;
00457 int rv= 0;
00458
00459 if (!buf) {
00460
00461 if(s->st && s->parse_packet) {
00462 timestamp= 0;
00463 rv= s->parse_packet(s->ic, s->dynamic_protocol_context,
00464 s->st, pkt, ×tamp, NULL, 0, flags);
00465 finalize_packet(s, pkt, timestamp);
00466 return rv;
00467 } else {
00468
00469 if (s->read_buf_index >= s->read_buf_size)
00470 return -1;
00471 ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index,
00472 s->read_buf_size - s->read_buf_index);
00473 if (ret < 0)
00474 return -1;
00475 s->read_buf_index += ret;
00476 if (s->read_buf_index < s->read_buf_size)
00477 return 1;
00478 else
00479 return 0;
00480 }
00481 }
00482
00483 if (len < 12)
00484 return -1;
00485
00486 if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
00487 return -1;
00488 if (buf[1] >= 200 && buf[1] <= 204) {
00489 rtcp_parse_packet(s, buf, len);
00490 return -1;
00491 }
00492 payload_type = buf[1] & 0x7f;
00493 if (buf[1] & 0x80)
00494 flags |= RTP_FLAG_MARKER;
00495 seq = AV_RB16(buf + 2);
00496 timestamp = AV_RB32(buf + 4);
00497 ssrc = AV_RB32(buf + 8);
00498
00499 s->ssrc = ssrc;
00500
00501
00502 if (s->payload_type != payload_type)
00503 return -1;
00504
00505 st = s->st;
00506
00507 if(!rtp_valid_packet_in_sequence(&s->statistics, seq))
00508 {
00509 av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
00510 payload_type, seq, ((s->seq + 1) & 0xffff));
00511 return -1;
00512 }
00513
00514 s->seq = seq;
00515 len -= 12;
00516 buf += 12;
00517
00518 if (!st) {
00519
00520 ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len);
00521 if (ret < 0)
00522 return -1;
00523 if (ret < len) {
00524 s->read_buf_size = len - ret;
00525 memcpy(s->buf, buf + ret, s->read_buf_size);
00526 s->read_buf_index = 0;
00527 return 1;
00528 }
00529 return 0;
00530 } else if (s->parse_packet) {
00531 rv = s->parse_packet(s->ic, s->dynamic_protocol_context,
00532 s->st, pkt, ×tamp, buf, len, flags);
00533 } else {
00534
00535 switch(st->codec->codec_id) {
00536 case CODEC_ID_MP2:
00537 case CODEC_ID_MP3:
00538
00539 if (len <= 4)
00540 return -1;
00541 h = AV_RB32(buf);
00542 len -= 4;
00543 buf += 4;
00544 av_new_packet(pkt, len);
00545 memcpy(pkt->data, buf, len);
00546 break;
00547 case CODEC_ID_MPEG1VIDEO:
00548 case CODEC_ID_MPEG2VIDEO:
00549
00550 if (len <= 4)
00551 return -1;
00552 h = AV_RB32(buf);
00553 buf += 4;
00554 len -= 4;
00555 if (h & (1 << 26)) {
00556
00557 if (len <= 4)
00558 return -1;
00559 buf += 4;
00560 len -= 4;
00561 }
00562 av_new_packet(pkt, len);
00563 memcpy(pkt->data, buf, len);
00564 break;
00565
00566
00567
00568 case CODEC_ID_AAC:
00569 if (rtp_parse_mp4_au(s, buf))
00570 return -1;
00571 {
00572 RTPPayloadData *infos = s->rtp_payload_data;
00573 if (infos == NULL)
00574 return -1;
00575 buf += infos->au_headers_length_bytes + 2;
00576 len -= infos->au_headers_length_bytes + 2;
00577
00578
00579
00580 av_new_packet(pkt, infos->au_headers[0].size);
00581 memcpy(pkt->data, buf, infos->au_headers[0].size);
00582 buf += infos->au_headers[0].size;
00583 len -= infos->au_headers[0].size;
00584 }
00585 s->read_buf_size = len;
00586 rv= 0;
00587 break;
00588 default:
00589 av_new_packet(pkt, len);
00590 memcpy(pkt->data, buf, len);
00591 break;
00592 }
00593
00594 pkt->stream_index = st->index;
00595 }
00596
00597
00598 finalize_packet(s, pkt, timestamp);
00599
00600 return rv;
00601 }
00602
00603 void rtp_parse_close(RTPDemuxContext *s)
00604 {
00605
00606 av_free(s->rtp_payload_data->mode);
00607 av_free(s->rtp_payload_data->au_headers);
00608 if (!strcmp(ff_rtp_enc_name(s->payload_type), "MP2T")) {
00609 ff_mpegts_parse_close(s->ts);
00610 }
00611 av_free(s);
00612 }