ffmpeg source update for sep 09

source/patched-ffmpeg-mt/libavformat/rtpdec.c

 /*
  * RTP input format
  * Copyright (c) 2002 Fabrice Bellard
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
@@ skipping 47 matching lines @@
     ff_register_dynamic_payload_handler(&ff_mpeg4_generic_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_amr_nb_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_amr_wb_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_h263_1998_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_h263_2000_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_h264_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_vorbis_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_theora_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_qdm2_dynamic_handler);
     ff_register_dynamic_payload_handler(&ff_svq3_dynamic_handler);
+    ff_register_dynamic_payload_handler(&ff_mp4a_latm_dynamic_handler);
+    ff_register_dynamic_payload_handler(&ff_vp8_dynamic_handler);
 
     ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfv_handler);
     ff_register_dynamic_payload_handler(&ff_ms_rtp_asf_pfa_handler);
 }
 
 static int rtcp_parse_packet(RTPDemuxContext *s, const unsigned char *buf, int len)
 {
-    if (buf[1] != 200)
-        return -1;
-    s->last_rtcp_ntp_time = AV_RB64(buf + 8);
-    if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
-        s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
-    s->last_rtcp_timestamp = AV_RB32(buf + 16);
-    return 0;
+    int payload_len;
+    while (len >= 2) {
+        switch (buf[1]) {
+        case RTCP_SR:
+            if (len < 16) {
+                av_log(NULL, AV_LOG_ERROR, "Invalid length for RTCP SR packet\n");
+                return AVERROR_INVALIDDATA;
+            }
+            payload_len = (AV_RB16(buf + 2) + 1) * 4;
+
+            s->last_rtcp_ntp_time = AV_RB64(buf + 8);
+            if (s->first_rtcp_ntp_time == AV_NOPTS_VALUE)
+                s->first_rtcp_ntp_time = s->last_rtcp_ntp_time;
+            s->last_rtcp_timestamp = AV_RB32(buf + 16);
+
+            buf += payload_len;
+            len -= payload_len;
+            break;
+        case RTCP_BYE:
+            return -RTCP_BYE;
+        default:
+            return -1;
+        }
+    }
+    return -1;
 }
 
 #define RTP_SEQ_MOD (1<<16)
 
 /**
 * called on parse open packet
 */
 static void rtp_init_statistics(RTPStatistics *s, uint16_t base_sequence) // called on parse open packet.
 {
     memset(s, 0, sizeof(RTPStatistics));
@@ skipping 108 matching lines @@
     rtcp_bytes /= 50; // mmu_man: that's enough for me... VLC sends much less btw !?
     if (rtcp_bytes < 28)
         return -1;
     s->last_octet_count = s->octet_count;
 
     if (url_open_dyn_buf(&pb) < 0)
         return -1;
 
     // Receiver Report
     put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
-    put_byte(pb, 201);
+    put_byte(pb, RTCP_RR);
     put_be16(pb, 7); /* length in words - 1 */
-    put_be32(pb, s->ssrc); // our own SSRC
-    put_be32(pb, s->ssrc); // XXX: should be the server's here!
+    // our own SSRC: we use the server's SSRC + 1 to avoid conflicts
+    put_be32(pb, s->ssrc + 1);
+    put_be32(pb, s->ssrc); // server SSRC
     // some placeholders we should really fill...
     // RFC 1889/p64
     extended_max= stats->cycles + stats->max_seq;
     expected= extended_max - stats->base_seq + 1;
     lost= expected - stats->received;
     lost= FFMIN(lost, 0xffffff); // clamp it since it's only 24 bits...
     expected_interval= expected - stats->expected_prior;
     stats->expected_prior= expected;
     received_interval= stats->received - stats->received_prior;
     stats->received_prior= stats->received;
@@ skipping 14 matching lines @@
     } else {
         uint32_t middle_32_bits= s->last_rtcp_ntp_time>>16; // this is valid, right? do we need to handle 64 bit values special?
         uint32_t delay_since_last= ntp_time - s->last_rtcp_ntp_time;
 
         put_be32(pb, middle_32_bits); /* last SR timestamp */
         put_be32(pb, delay_since_last); /* delay since last SR */
     }
 
     // CNAME
     put_byte(pb, (RTP_VERSION << 6) + 1); /* 1 report block */
-    put_byte(pb, 202);
+    put_byte(pb, RTCP_SDES);
     len = strlen(s->hostname);
     put_be16(pb, (6 + len + 3) / 4); /* length in words - 1 */
     put_be32(pb, s->ssrc);
     put_byte(pb, 0x01);
     put_byte(pb, len);
     put_buffer(pb, s->hostname, len);
     // padding
     for (len = (6 + len) % 4; len % 4; len++) {
         put_byte(pb, 0);
     }
@@ skipping 30 matching lines @@
     len = url_close_dyn_buf(pb, &buf);
     if ((len > 0) && buf)
         url_write(rtp_handle, buf, len);
     av_free(buf);
 
     /* Send a minimal RTCP RR */
     if (url_open_dyn_buf(&pb) < 0)
         return;
 
     put_byte(pb, (RTP_VERSION << 6));
-    put_byte(pb, 201); /* receiver report */
+    put_byte(pb, RTCP_RR); /* receiver report */
     put_be16(pb, 1); /* length in words - 1 */
     put_be32(pb, 0); /* our own SSRC */
 
     put_flush_packet(pb);
     len = url_close_dyn_buf(pb, &buf);
     if ((len > 0) && buf)
         url_write(rtp_handle, buf, len);
     av_free(buf);
 }
 
@@ skipping 114 matching lines @@
             else
                 return 0;
         }
     }
 
     if (len < 12)
         return -1;
 
     if ((buf[0] & 0xc0) != (RTP_VERSION << 6))
         return -1;
-    if (buf[1] >= 200 && buf[1] <= 204) {
-        rtcp_parse_packet(s, buf, len);
-        return -1;
+    if (buf[1] >= RTCP_SR && buf[1] <= RTCP_APP) {
+        return rtcp_parse_packet(s, buf, len);
     }
     payload_type = buf[1] & 0x7f;
     if (buf[1] & 0x80)
         flags |= RTP_FLAG_MARKER;
     seq  = AV_RB16(buf + 2);
     timestamp = AV_RB32(buf + 4);
     ssrc = AV_RB32(buf + 8);
     /* store the ssrc in the RTPDemuxContext */
     s->ssrc = ssrc;
 
@@ skipping 110 matching lines @@
 
         res = parse_fmtp(stream, data, attr, value);
         if (res < 0 && res != AVERROR_PATCHWELCOME) {
             av_free(value);
             return res;
         }
     }
     av_free(value);
     return 0;
 }