Temporary rollback to be able to build on Windows. Will be fixed soon.

git-svn-id: http://webrtc.googlecode.com/svn/trunk@82 4adac7df-926f-26a2-2b94-8c16560cd09d

modules/rtp_rtcp/source/rtp_format_vp8.cc

@@ -11,133 +11,147 @@
 #include "rtp_format_vp8.h"
 
 #include <cassert>  // assert
-#include <math.h>   // ceil, round
 #include <string.h> // memcpy
 
 namespace webrtc {
 
-// Define how the VP8PacketizerModes are implemented.
-// Modes are: kStrict, kAggregate, kSloppy.
-const RtpFormatVp8::AggregationMode RtpFormatVp8::aggr_modes_[kNumModes] =
-    { kAggrNone, kAggrPartitions, kAggrFragments };
-const bool RtpFormatVp8::bal_modes_[kNumModes] =
-    { true, false, false };
-const bool RtpFormatVp8::sep_first_modes_[kNumModes] =
-    { true, false, false };
-
 RtpFormatVp8::RtpFormatVp8(const WebRtc_UWord8* payload_data,
                            WebRtc_UWord32 payload_size,
-                           const RTPFragmentationHeader& fragmentation,
+                           const RTPFragmentationHeader* fragmentation,
                            VP8PacketizerMode mode)
     : payload_data_(payload_data),
       payload_size_(payload_size),
       payload_bytes_sent_(0),
-      part_ix_(0),
+      mode_(mode),
       beginning_(true),
       first_fragment_(true),
-      vp8_header_bytes_(1),
+      vp8_header_bytes_(1)
-      aggr_mode_(aggr_modes_[mode]),
-      balance_(bal_modes_[mode]),
-      separate_first_(sep_first_modes_[mode])
 {
-    part_info_ = fragmentation;
+    if (fragmentation == NULL)
+    {
+        // Cannot do kStrict or kAggregate without fragmentation info.
+        // Change to kSloppy.
+        mode_ = kSloppy;
+    }
+    else
+    {
+        frag_info_ = *fragmentation;
+    }
 }
 
 RtpFormatVp8::RtpFormatVp8(const WebRtc_UWord8* payload_data,
                            WebRtc_UWord32 payload_size)
     : payload_data_(payload_data),
       payload_size_(payload_size),
-      part_info_(),
+      frag_info_(),
       payload_bytes_sent_(0),
-      part_ix_(0),
+      mode_(kSloppy),
       beginning_(true),
       first_fragment_(true),
-      vp8_header_bytes_(1),
+      vp8_header_bytes_(1)
-      aggr_mode_(aggr_modes_[kSloppy]),
+{}
-      balance_(bal_modes_[kSloppy]),
-      separate_first_(sep_first_modes_[kSloppy])
-{
-    part_info_.VerifyAndAllocateFragmentationHeader(1);
-    part_info_.fragmentationLength[0] = payload_size_;
-    part_info_.fragmentationOffset[0] = 0;
-}
 
-int RtpFormatVp8::CalcNextSize(int max_payload_len, int remaining_bytes,
+int RtpFormatVp8::GetFragIdx()
-                               bool split_payload) const
 {
-    if (max_payload_len == 0 || remaining_bytes == 0)
+    // Which fragment are we in?
+    int frag_ix = 0;
+    while ((frag_ix + 1 < frag_info_.fragmentationVectorSize) &&
+        (payload_bytes_sent_ >= frag_info_.fragmentationOffset[frag_ix + 1]))
     {
-        return 0;
+        ++frag_ix;
-    }
-    if (!split_payload)
-    {
-        return max_payload_len >= remaining_bytes ? remaining_bytes : 0;
-    }
-
-    if (balance_)
-    {
-        // Balance payload sizes to produce (almost) equal size
-        // fragments.
-        // Number of fragments for remaining_bytes:
-        int num_frags = ceil(
-            static_cast<double>(remaining_bytes) / max_payload_len);
-        // Number of bytes in this fragment:
-        return static_cast<int>(round(
-            static_cast<double>(remaining_bytes) / num_frags));
-    }
-    else
-    {
-        return max_payload_len >= remaining_bytes ? remaining_bytes
-            : max_payload_len;
     }
+    return frag_ix;
 }
 
 int RtpFormatVp8::NextPacket(int max_payload_len, WebRtc_UWord8* buffer,
                              int* bytes_to_send, bool* last_packet)
 {
-    const int num_partitions = part_info_.fragmentationVectorSize;
+    // Convenience variables
+    const int num_fragments = frag_info_.fragmentationVectorSize;
+    int frag_ix = GetFragIdx(); //TODO (hlundin): Store frag_ix as a member?
     int send_bytes = 0; // How much data to send in this packet.
-    bool split_payload = true; // Splitting of partitions is initially allowed.
+    bool end_of_fragment = false;
-    int remaining_in_partition = part_info_.fragmentationOffset[part_ix_]
-        - payload_bytes_sent_ + part_info_.fragmentationLength[part_ix_];
-    int rem_payload_len = max_payload_len - vp8_header_bytes_;
 
-    while (int next_size = CalcNextSize(rem_payload_len, remaining_in_partition,
+    switch (mode_)
-        split_payload))
     {
-        send_bytes += next_size;
+        case kAggregate:
-        rem_payload_len -= next_size;
+        {
-        remaining_in_partition -= next_size;
+            // Check if we are at the beginning of a new partition.
+            if (first_fragment_)
+            {
+                // Check if this fragment fits in one packet.
+                if (frag_info_.fragmentationLength[frag_ix] + vp8_header_bytes_
+                    <= max_payload_len)
+                {
+                    // Pack as many whole partitions we can into this packet;
+                    // don't fragment.
+                    while ((frag_ix < num_fragments) &&
+                        (send_bytes + vp8_header_bytes_
+                        + frag_info_.fragmentationLength[frag_ix]
+                        <= max_payload_len))
+                    {
+                        send_bytes += frag_info_.fragmentationLength[frag_ix];
+                        ++frag_ix;
+                    }
 
-        if (remaining_in_partition == 0 && !(beginning_ && separate_first_))
+                    // This packet ends on a complete fragment.
-        {
+                    end_of_fragment = true;
-            // Advance to next partition?
+                    break; // Jump out of case statement.
-            // Check that there are more partitions; verify that we are either
-            // allowed to aggregate fragments, or that we are allowed to
-            // aggregate intact partitions and that we started this packet
-            // with an intact partition (indicated by first_fragment_ == true).
-            if (part_ix_ + 1 < num_partitions &&
-                ((aggr_mode_ == kAggrFragments) ||
-                 (aggr_mode_ == kAggrPartitions && first_fragment_)))
-            {
-                remaining_in_partition
-                    = part_info_.fragmentationLength[++part_ix_];
-                // Disallow splitting unless kAggrFragments. In kAggrPartitions,
-                // we can only aggregate intact partitions.
-                split_payload = (aggr_mode_ == kAggrFragments);
                 }
             }
-        else if (balance_ && remaining_in_partition > 0)
+
+            // Either we are not starting this packet with a new partition,
+            // or the partition is too large for a packet.
+            // Move on to "case kStrict".
+            // NOTE: break intentionally omitted!
+        }
+
+        case kStrict: // Can also continue to here from kAggregate.
         {
+            // Find out how much is left to send in the current partition.
+            const int remaining_bytes = frag_info_.fragmentationOffset[frag_ix]
+                - payload_bytes_sent_ + frag_info_.fragmentationLength[frag_ix];
+            assert(remaining_bytes > 0);
+            assert(remaining_bytes <= frag_info_.fragmentationLength[frag_ix]);
+
+            if (remaining_bytes + vp8_header_bytes_ > max_payload_len)
+            {
+                // send one full packet
+                send_bytes = max_payload_len - vp8_header_bytes_;
+            }
+            else
+            {
+                // last packet from this partition
+                send_bytes = remaining_bytes;
+                end_of_fragment = true;
+            }
             break;
         }
-    }
+
-    if (remaining_in_partition == 0)
+        case kSloppy:
         {
-        ++part_ix_; // Advance to next partition.
+            // Send a full packet, or what is left of the payload.
+            const int remaining_bytes = payload_size_ - payload_bytes_sent_;
+
+            if (remaining_bytes + vp8_header_bytes_ > max_payload_len)
+            {
+                send_bytes = max_payload_len - vp8_header_bytes_;
+                end_of_fragment = false;
+            }
+            else
+            {
+                send_bytes = remaining_bytes;
+                end_of_fragment = true;
+            }
+            break;
+        }
+
+        default:
+            // Should not end up here
+            assert(false);
+            return -1;
     }
 
-    const bool end_of_fragment = (remaining_in_partition == 0);
     // Write the payload header and the payload to buffer.
     *bytes_to_send = WriteHeaderAndPayload(send_bytes, end_of_fragment, buffer);
     if (*bytes_to_send < 0)
@@ -145,7 +159,7 @@ int RtpFormatVp8::NextPacket(int max_payload_len, WebRtc_UWord8* buffer,
         return -1;
     }
 
-    *last_packet = (payload_bytes_sent_ >= payload_size_);
+    *last_packet = payload_bytes_sent_ >= payload_size_;
     assert(!*last_packet || (payload_bytes_sent_ == payload_size_));
     return 0;
 }

modules/rtp_rtcp/source/rtp_format_vp8.h

@@ -33,10 +33,9 @@ namespace webrtc
 
 enum VP8PacketizerMode
 {
-    kStrict = 0, // split partitions if too large; never aggregate, balance size
+    kStrict = 0, // split partitions if too large; never aggregate partitions
     kAggregate, // split partitions if too large; aggregate whole partitions
-    kSloppy,     // split entire payload without considering partition limits
+    kSloppy, // split entire payload without considering partition boundaries
-    kNumModes,
 };
 
 // Packetizer for VP8.
@@ -47,7 +46,7 @@ public:
     // The payload_data must be exactly one encoded VP8 frame.
     RtpFormatVp8(const WebRtc_UWord8* payload_data,
                  WebRtc_UWord32 payload_size,
-                 const RTPFragmentationHeader& fragmentation,
+                 const RTPFragmentationHeader* fragmentation,
                  VP8PacketizerMode mode);
 
     // Initialize without fragmentation info. Mode kSloppy will be used.
@@ -66,20 +65,8 @@ public:
                    int* bytes_to_send, bool* last_packet);
 
 private:
-    enum AggregationMode
+    // Determine from which fragment the next byte to send will be taken.
-    {
+    int GetFragIdx();
-        kAggrNone = 0,   // no aggregation
-        kAggrPartitions, // aggregate intact partitions
-        kAggrFragments   // aggregate intact and fragmented partitions
-    };
-
-    static const AggregationMode aggr_modes_[kNumModes];
-    static const bool bal_modes_[kNumModes];
-    static const bool sep_first_modes_[kNumModes];
-
-    // Calculate size of next chunk to send. Returns 0 if none can be sent.
-    int CalcNextSize(int max_payload_len, int remaining_bytes,
-                     bool split_payload) const;
 
     // Write the payload header and copy the payload to the buffer.
     // Will copy send_bytes bytes from the current position on the payload data.
@@ -90,15 +77,12 @@ private:
 
     const WebRtc_UWord8* payload_data_;
     const WebRtc_UWord32 payload_size_;
-    RTPFragmentationHeader part_info_;
+    RTPFragmentationHeader frag_info_;
     int payload_bytes_sent_;
-    int part_ix_;
+    VP8PacketizerMode mode_;
     bool beginning_; // first partition in this frame
     bool first_fragment_; // first fragment of a partition
     const int vp8_header_bytes_; // length of VP8 payload header
-    AggregationMode aggr_mode_;
-    bool balance_;
-    bool separate_first_;
 };
 
 }

modules/rtp_rtcp/source/rtp_sender_video.cc

@@ -1106,7 +1106,7 @@ RTPSenderVideo::SendVP8(const FrameType frameType,
     WebRtc_UWord16 maxPayloadLengthVP8 = _rtpSender.MaxPayloadLength()
         - FECPacketOverhead() - rtpHeaderLength;
 
-    RtpFormatVp8 packetizer(data, payloadBytesToSend, *fragmentation, kStrict);
+    RtpFormatVp8 packetizer(data, payloadBytesToSend, fragmentation, kStrict);
 
     bool last = false;
     while (!last)