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