Make r80 build on Windows

Re-submitting revision r80, but with bugfix to make it
build on Windows.

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

modules/rtp_rtcp/source/rtp_format_vp8.cc

@@ -11,147 +11,133 @@
 #include "rtp_format_vp8.h"
 
 #include <cassert>  // assert
+#include <math.h>   // ceil
 #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),
-      mode_(mode),
+      part_ix_(0),
       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])
 {
-    if (fragmentation == NULL)
+    part_info_ = fragmentation;
-    {
-        // 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),
-      frag_info_(),
+      part_info_(),
       payload_bytes_sent_(0),
-      mode_(kSloppy),
+      part_ix_(0),
       beginning_(true),
       first_fragment_(true),
-      vp8_header_bytes_(1)
+      vp8_header_bytes_(1),
-{}
+      aggr_mode_(aggr_modes_[kSloppy]),
-
+      balance_(bal_modes_[kSloppy]),
-int RtpFormatVp8::GetFragIdx()
+      separate_first_(sep_first_modes_[kSloppy])
 {
-    // Which fragment are we in?
+    part_info_.VerifyAndAllocateFragmentationHeader(1);
-    int frag_ix = 0;
+    part_info_.fragmentationLength[0] = payload_size_;
-    while ((frag_ix + 1 < frag_info_.fragmentationVectorSize) &&
+    part_info_.fragmentationOffset[0] = 0;
-        (payload_bytes_sent_ >= frag_info_.fragmentationOffset[frag_ix + 1]))
+}
+
+int RtpFormatVp8::CalcNextSize(int max_payload_len, int remaining_bytes,
+                               bool split_payload) const
+{
+    if (max_payload_len == 0 || remaining_bytes == 0)
     {
-        ++frag_ix;
+        return 0;
+    }
+    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>(static_cast<double>(remaining_bytes)
+            / num_frags + 0.5);
+    }
+    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)
 {
-    // Convenience variables
+    const int num_partitions = part_info_.fragmentationVectorSize;
-    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 end_of_fragment = false;
+    bool split_payload = true; // Splitting of partitions is initially allowed.
+    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_;
 
-    switch (mode_)
+    while (int next_size = CalcNextSize(rem_payload_len, remaining_in_partition,
+        split_payload))
     {
-        case kAggregate:
+        send_bytes += next_size;
-        {
+        rem_payload_len -= next_size;
-            // Check if we are at the beginning of a new partition.
+        remaining_in_partition -= next_size;
-            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;
-                    }
 
-                    // This packet ends on a complete fragment.
+        if (remaining_in_partition == 0 && !(beginning_ && separate_first_))
-                    end_of_fragment = true;
-                    break; // Jump out of case statement.
-                }
-            }
-
-            // 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.
+            // Advance to next partition?
-            const int remaining_bytes = frag_info_.fragmentationOffset[frag_ix]
+            // Check that there are more partitions; verify that we are either
-                - payload_bytes_sent_ + frag_info_.fragmentationLength[frag_ix];
+            // allowed to aggregate fragments, or that we are allowed to
-            assert(remaining_bytes > 0);
+            // aggregate intact partitions and that we started this packet
-            assert(remaining_bytes <= frag_info_.fragmentationLength[frag_ix]);
+            // with an intact partition (indicated by first_fragment_ == true).
-
+            if (part_ix_ + 1 < num_partitions &&
-            if (remaining_bytes + vp8_header_bytes_ > max_payload_len)
+                ((aggr_mode_ == kAggrFragments) ||
+                 (aggr_mode_ == kAggrPartitions && first_fragment_)))
             {
-                // send one full packet
+                remaining_in_partition
-                send_bytes = max_payload_len - vp8_header_bytes_;
+                    = part_info_.fragmentationLength[++part_ix_];
+                // Disallow splitting unless kAggrFragments. In kAggrPartitions,
+                // we can only aggregate intact partitions.
+                split_payload = (aggr_mode_ == kAggrFragments);
             }
-            else
+        }
+        else if (balance_ && remaining_in_partition > 0)
         {
-                // last packet from this partition
-                send_bytes = remaining_bytes;
-                end_of_fragment = true;
-            }
             break;
         }
-
+    }
-        case kSloppy:
+    if (remaining_in_partition == 0)
     {
-            // Send a full packet, or what is left of the payload.
+        ++part_ix_; // Advance to next partition.
-            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)
@@ -159,7 +145,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,9 +33,10 @@ namespace webrtc
 
 enum VP8PacketizerMode
 {
-    kStrict = 0, // split partitions if too large; never aggregate partitions
+    kStrict = 0, // split partitions if too large; never aggregate, balance size
     kAggregate,  // split partitions if too large; aggregate whole partitions
-    kSloppy, // split entire payload without considering partition boundaries
+    kSloppy,     // split entire payload without considering partition limits
+    kNumModes,
 };
 
 // Packetizer for VP8.
@@ -46,7 +47,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.
@@ -65,8 +66,20 @@ public:
                    int* bytes_to_send, bool* last_packet);
 
 private:
-    // Determine from which fragment the next byte to send will be taken.
+    enum AggregationMode
-    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.
@@ -77,12 +90,15 @@ private:
 
     const WebRtc_UWord8* payload_data_;
     const WebRtc_UWord32 payload_size_;
-    RTPFragmentationHeader frag_info_;
+    RTPFragmentationHeader part_info_;
     int payload_bytes_sent_;
-    VP8PacketizerMode mode_;
+    int part_ix_;
     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)