Home | History | Annotate | Download | only in framer
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/test/simple_test_tick_clock.h"
      6 #include "media/cast/framer/framer.h"
      7 #include "media/cast/rtp_receiver/mock_rtp_payload_feedback.h"
      8 #include "testing/gtest/include/gtest/gtest.h"
      9 
     10 namespace media {
     11 namespace cast {
     12 
     13 class FramerTest : public ::testing::Test {
     14  protected:
     15   FramerTest()
     16       : mock_rtp_payload_feedback_(),
     17         framer_(&testing_clock_, &mock_rtp_payload_feedback_, 0, true, 0) {
     18   }
     19 
     20   virtual ~FramerTest() {}
     21 
     22   virtual void SetUp() OVERRIDE {
     23     // Build a default one packet frame - populate webrtc header.
     24     rtp_header_.is_key_frame = false;
     25     rtp_header_.frame_id = 0;
     26     rtp_header_.packet_id = 0;
     27     rtp_header_.max_packet_id = 0;
     28     rtp_header_.is_reference = false;
     29     rtp_header_.reference_frame_id = 0;
     30     payload_.assign(kIpPacketSize, 0);
     31 
     32     EXPECT_CALL(mock_rtp_payload_feedback_,
     33                 CastFeedback(testing::_)).WillRepeatedly(testing::Return());
     34   }
     35 
     36   std::vector<uint8> payload_;
     37   RtpCastHeader rtp_header_;
     38   MockRtpPayloadFeedback mock_rtp_payload_feedback_;
     39   Framer framer_;
     40   base::SimpleTestTickClock testing_clock_;
     41 };
     42 
     43 
     44 TEST_F(FramerTest, EmptyState) {
     45   EncodedVideoFrame frame;
     46   uint32 rtp_timestamp;
     47   bool next_frame = false;
     48   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
     49                                             &next_frame));
     50 }
     51 
     52 TEST_F(FramerTest, AlwaysStartWithKey) {
     53   EncodedVideoFrame frame;
     54   uint32 rtp_timestamp;
     55   bool next_frame = false;
     56 
     57   // Insert non key first frame.
     58   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
     59   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
     60                                             &next_frame));
     61   rtp_header_.frame_id = 1;
     62   rtp_header_.is_key_frame = true;
     63   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
     64   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
     65                                            &next_frame));
     66   EXPECT_TRUE(next_frame);
     67   EXPECT_EQ(1u, frame.frame_id);
     68   EXPECT_TRUE(frame.key_frame);
     69   framer_.ReleaseFrame(frame.frame_id);
     70 }
     71 
     72 TEST_F(FramerTest, CompleteFrame) {
     73   EncodedVideoFrame frame;
     74   uint32 rtp_timestamp;
     75   bool next_frame = false;
     76 
     77   // start with a complete key frame.
     78   rtp_header_.is_key_frame = true;
     79   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
     80   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
     81                                            &next_frame));
     82   EXPECT_TRUE(next_frame);
     83   EXPECT_EQ(0u, frame.frame_id);
     84   EXPECT_TRUE(frame.key_frame);
     85   framer_.ReleaseFrame(frame.frame_id);
     86 
     87   // Incomplete delta.
     88   ++rtp_header_.frame_id;
     89   rtp_header_.is_key_frame = false;
     90   rtp_header_.max_packet_id = 2;
     91   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
     92   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
     93                                             &next_frame));
     94 
     95   // Complete delta - can't skip, as incomplete sequence.
     96   ++rtp_header_.frame_id;
     97   rtp_header_.max_packet_id = 0;
     98   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
     99   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    100                                             &next_frame));
    101 }
    102 
    103 TEST_F(FramerTest, ContinuousSequence) {
    104   EncodedVideoFrame frame;
    105   uint32 rtp_timestamp;
    106   bool next_frame = false;
    107 
    108   // start with a complete key frame.
    109   rtp_header_.is_key_frame = true;
    110   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    111   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    112                                            &next_frame));
    113   EXPECT_TRUE(next_frame);
    114   EXPECT_EQ(0u, frame.frame_id);
    115   EXPECT_TRUE(frame.key_frame);
    116   framer_.ReleaseFrame(frame.frame_id);
    117 
    118   // Complete - not continuous.
    119   rtp_header_.frame_id = 2;
    120   rtp_header_.is_key_frame = false;
    121   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    122   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    123                                             &next_frame));
    124 }
    125 
    126 TEST_F(FramerTest, Wrap) {
    127   // Insert key frame, frame_id = 255 (will jump to that)
    128   EncodedVideoFrame frame;
    129   uint32 rtp_timestamp;
    130   bool next_frame = false;
    131 
    132   // Start with a complete key frame.
    133   rtp_header_.is_key_frame = true;
    134   rtp_header_.frame_id = 255u;
    135   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    136   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    137                                            &next_frame));
    138   EXPECT_TRUE(next_frame);
    139   EXPECT_EQ(255u, frame.frame_id);
    140   framer_.ReleaseFrame(frame.frame_id);
    141 
    142   // Insert wrapped delta frame - should be continuous.
    143   rtp_header_.is_key_frame = false;
    144   rtp_header_.frame_id = 256;
    145   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    146   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    147                                            &next_frame));
    148   EXPECT_TRUE(next_frame);
    149   EXPECT_EQ(256u, frame.frame_id);
    150   framer_.ReleaseFrame(frame.frame_id);
    151 }
    152 
    153 TEST_F(FramerTest, Reset) {
    154   EncodedVideoFrame frame;
    155   uint32 rtp_timestamp;
    156   bool next_frame = false;
    157 
    158   // Start with a complete key frame.
    159   rtp_header_.is_key_frame = true;
    160   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    161   framer_.Reset();
    162   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    163                                             &next_frame));
    164 }
    165 
    166 TEST_F(FramerTest, RequireKeyAfterReset) {
    167   EncodedVideoFrame frame;
    168   uint32 rtp_timestamp;
    169   bool next_frame = false;
    170   framer_.Reset();
    171 
    172   // Start with a complete key frame.
    173   rtp_header_.is_key_frame = false;
    174   rtp_header_.frame_id = 0u;
    175   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    176   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    177                                             &next_frame));
    178   rtp_header_.frame_id = 1;
    179   rtp_header_.is_key_frame = true;
    180   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    181   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    182                                            &next_frame));
    183   EXPECT_TRUE(next_frame);
    184 }
    185 
    186 TEST_F(FramerTest, BasicNonLastReferenceId) {
    187   EncodedVideoFrame frame;
    188   uint32 rtp_timestamp;
    189   bool next_frame = false;
    190   rtp_header_.is_key_frame = true;
    191   rtp_header_.frame_id = 0;
    192   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    193 
    194   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    195                                            &next_frame));
    196   framer_.ReleaseFrame(frame.frame_id);
    197 
    198   rtp_header_.is_key_frame = false;
    199   rtp_header_.is_reference = true;
    200   rtp_header_.reference_frame_id = 0;
    201   rtp_header_.frame_id = 5u;
    202   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    203 
    204   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    205                                            &next_frame));
    206   EXPECT_FALSE(next_frame);
    207 }
    208 
    209 TEST_F(FramerTest, InOrderReferenceFrameSelection) {
    210   // Create pattern: 0, 1, 4, 5.
    211   EncodedVideoFrame frame;
    212   uint32 rtp_timestamp;
    213   bool next_frame = false;
    214 
    215   rtp_header_.is_key_frame = true;
    216   rtp_header_.frame_id = 0;
    217   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    218   rtp_header_.is_key_frame = false;
    219   rtp_header_.frame_id = 1;
    220   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    221 
    222   // Insert frame #2 partially.
    223   rtp_header_.frame_id = 2;
    224   rtp_header_.max_packet_id = 1;
    225   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    226   rtp_header_.frame_id = 4;
    227   rtp_header_.max_packet_id = 0;
    228   rtp_header_.is_reference = true;
    229   rtp_header_.reference_frame_id = 0;
    230   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    231   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    232                                            &next_frame));
    233   EXPECT_EQ(0u, frame.frame_id);
    234   framer_.ReleaseFrame(frame.frame_id);
    235   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    236                                            &next_frame));
    237   EXPECT_TRUE(next_frame);
    238   EXPECT_EQ(1u, frame.frame_id);
    239   framer_.ReleaseFrame(frame.frame_id);
    240   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    241                                            &next_frame));
    242   EXPECT_FALSE(next_frame);
    243   EXPECT_EQ(4u, frame.frame_id);
    244   framer_.ReleaseFrame(frame.frame_id);
    245   // Insert remaining packet of frame #2 - should no be continuous.
    246   rtp_header_.frame_id = 2;
    247   rtp_header_.packet_id = 1;
    248   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    249   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    250                                             &next_frame));
    251   rtp_header_.is_reference = false;
    252   rtp_header_.frame_id = 5;
    253   rtp_header_.packet_id = 0;
    254   rtp_header_.max_packet_id = 0;
    255   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    256   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &rtp_timestamp,
    257                                            &next_frame));
    258   EXPECT_TRUE(next_frame);
    259   EXPECT_EQ(5u, frame.frame_id);
    260 }
    261 
    262 TEST_F(FramerTest, AudioWrap) {
    263   // All audio frames are marked as key frames.
    264   EncodedAudioFrame frame;
    265   uint32 rtp_timestamp;
    266   bool next_frame = false;
    267   rtp_header_.is_key_frame = true;
    268   rtp_header_.frame_id = 254;
    269 
    270   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    271   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
    272                                            &next_frame));
    273   EXPECT_TRUE(next_frame);
    274   EXPECT_EQ(254u, frame.frame_id);
    275   framer_.ReleaseFrame(frame.frame_id);
    276 
    277   rtp_header_.frame_id = 255;
    278   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    279 
    280   // Insert wrapped frame - should be continuous.
    281   rtp_header_.frame_id = 256;
    282   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    283 
    284   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
    285                                            &next_frame));
    286   EXPECT_TRUE(next_frame);
    287   EXPECT_EQ(255u, frame.frame_id);
    288   framer_.ReleaseFrame(frame.frame_id);
    289 
    290   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
    291                                            &next_frame));
    292   EXPECT_TRUE(next_frame);
    293   EXPECT_EQ(256u, frame.frame_id);
    294   framer_.ReleaseFrame(frame.frame_id);
    295 }
    296 
    297 TEST_F(FramerTest, AudioWrapWithMissingFrame) {
    298   // All audio frames are marked as key frames.
    299   EncodedAudioFrame frame;
    300   uint32 rtp_timestamp;
    301   bool next_frame = false;
    302 
    303   // Insert and get first packet.
    304   rtp_header_.is_key_frame = true;
    305   rtp_header_.frame_id = 253;
    306   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    307   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
    308                                            &next_frame));
    309   EXPECT_TRUE(next_frame);
    310   EXPECT_EQ(253u, frame.frame_id);
    311   framer_.ReleaseFrame(frame.frame_id);
    312 
    313   // Insert third and fourth packets.
    314   rtp_header_.frame_id = 255;
    315   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    316   rtp_header_.frame_id = 256;
    317   framer_.InsertPacket(payload_.data(), payload_.size(), rtp_header_);
    318 
    319   // Get third and fourth packets.
    320   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
    321                                            &next_frame));
    322   EXPECT_FALSE(next_frame);
    323   EXPECT_EQ(255u, frame.frame_id);
    324   framer_.ReleaseFrame(frame.frame_id);
    325   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &rtp_timestamp,
    326                                            &next_frame));
    327   EXPECT_TRUE(next_frame);
    328   EXPECT_EQ(256u, frame.frame_id);
    329   framer_.ReleaseFrame(frame.frame_id);
    330 }
    331 
    332 }  // namespace cast
    333 }  // namespace media
    334