1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/stringprintf.h"
#include "media/base/android/media_codec_bridge.h"
#include "media/base/android/media_drm_bridge.h"
#include "media/base/android/media_player_manager.h"
#include "media/base/android/media_source_player.h"
#include "media/base/bind_to_loop.h"
#include "media/base/decoder_buffer.h"
#include "media/base/test_data_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "ui/gl/android/surface_texture.h"
namespace media {
// Helper macro to skip the test if MediaCodecBridge isn't available.
#define SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE() \
do { \
if (!MediaCodecBridge::IsAvailable()) { \
VLOG(0) << "Could not run test - not supported on device."; \
return; \
} \
} while (0)
static const int kDefaultDurationInMs = 10000;
static const char kAudioMp4[] = "audio/mp4";
static const char kVideoMp4[] = "video/mp4";
static const char kAudioWebM[] = "audio/webm";
static const char kVideoWebM[] = "video/webm";
// Mock of MediaPlayerManager for testing purpose
class MockMediaPlayerManager : public MediaPlayerManager {
public:
explicit MockMediaPlayerManager(base::MessageLoop* message_loop)
: message_loop_(message_loop),
playback_completed_(false) {}
virtual ~MockMediaPlayerManager() {}
// MediaPlayerManager implementation.
virtual void RequestMediaResources(int player_id) OVERRIDE {}
virtual void ReleaseMediaResources(int player_id) OVERRIDE {}
virtual MediaResourceGetter* GetMediaResourceGetter() OVERRIDE {
return NULL;
}
virtual void OnTimeUpdate(int player_id,
base::TimeDelta current_time) OVERRIDE {}
virtual void OnMediaMetadataChanged(
int player_id, base::TimeDelta duration, int width, int height,
bool success) OVERRIDE {}
virtual void OnPlaybackComplete(int player_id) OVERRIDE {
playback_completed_ = true;
if (message_loop_->is_running())
message_loop_->Quit();
}
virtual void OnMediaInterrupted(int player_id) OVERRIDE {}
virtual void OnBufferingUpdate(int player_id, int percentage) OVERRIDE {}
virtual void OnSeekComplete(int player_id,
const base::TimeDelta& current_time) OVERRIDE {}
virtual void OnError(int player_id, int error) OVERRIDE {}
virtual void OnVideoSizeChanged(int player_id, int width,
int height) OVERRIDE {}
virtual MediaPlayerAndroid* GetFullscreenPlayer() OVERRIDE { return NULL; }
virtual MediaPlayerAndroid* GetPlayer(int player_id) OVERRIDE { return NULL; }
virtual void DestroyAllMediaPlayers() OVERRIDE {}
virtual MediaDrmBridge* GetDrmBridge(int media_keys_id) OVERRIDE {
return NULL;
}
virtual void OnProtectedSurfaceRequested(int player_id) OVERRIDE {}
virtual void OnSessionCreated(int media_keys_id,
uint32 reference_id,
const std::string& session_id) OVERRIDE {}
virtual void OnSessionMessage(int media_keys_id,
uint32 reference_id,
const std::vector<uint8>& message,
const std::string& destination_url) OVERRIDE {}
virtual void OnSessionReady(int media_keys_id,
uint32 reference_id) OVERRIDE {}
virtual void OnSessionClosed(int media_keys_id,
uint32 reference_id) OVERRIDE {}
virtual void OnSessionError(int media_keys_id,
uint32 reference_id,
media::MediaKeys::KeyError error_code,
int system_code) OVERRIDE {}
bool playback_completed() const {
return playback_completed_;
}
private:
base::MessageLoop* message_loop_;
bool playback_completed_;
DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
};
class MockDemuxerAndroid : public DemuxerAndroid {
public:
explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
: message_loop_(message_loop),
num_data_requests_(0),
num_seek_requests_(0),
num_browser_seek_requests_(0),
num_config_requests_(0) {}
virtual ~MockDemuxerAndroid() {}
virtual void Initialize(DemuxerAndroidClient* client) OVERRIDE {}
virtual void RequestDemuxerConfigs() OVERRIDE {
num_config_requests_++;
}
virtual void RequestDemuxerData(DemuxerStream::Type type) OVERRIDE {
num_data_requests_++;
if (message_loop_->is_running())
message_loop_->Quit();
}
virtual void RequestDemuxerSeek(const base::TimeDelta& time_to_seek,
bool is_browser_seek) OVERRIDE {
num_seek_requests_++;
if (is_browser_seek)
num_browser_seek_requests_++;
}
int num_data_requests() const { return num_data_requests_; }
int num_seek_requests() const { return num_seek_requests_; }
int num_browser_seek_requests() const { return num_browser_seek_requests_; }
int num_config_requests() const { return num_config_requests_; }
private:
base::MessageLoop* message_loop_;
// The number of encoded data requests this object has seen.
int num_data_requests_;
// The number of regular and browser seek requests this object has seen.
int num_seek_requests_;
// The number of browser seek requests this object has seen.
int num_browser_seek_requests_;
// The number of demuxer config requests this object has seen.
int num_config_requests_;
DISALLOW_COPY_AND_ASSIGN(MockDemuxerAndroid);
};
class MediaSourcePlayerTest : public testing::Test {
public:
MediaSourcePlayerTest()
: manager_(&message_loop_),
demuxer_(new MockDemuxerAndroid(&message_loop_)),
player_(0, &manager_, scoped_ptr<DemuxerAndroid>(demuxer_)),
decoder_callback_hook_executed_(false),
surface_texture_a_is_next_(true) {}
virtual ~MediaSourcePlayerTest() {}
protected:
// Get the decoder job from the MediaSourcePlayer.
MediaDecoderJob* GetMediaDecoderJob(bool is_audio) {
if (is_audio) {
return reinterpret_cast<MediaDecoderJob*>(
player_.audio_decoder_job_.get());
}
return reinterpret_cast<MediaDecoderJob*>(
player_.video_decoder_job_.get());
}
// Get the per-job prerolling status from the MediaSourcePlayer's job matching
// |is_audio|. Caller must guard against NPE if the player's job is NULL.
bool IsPrerolling(bool is_audio) {
return GetMediaDecoderJob(is_audio)->prerolling();
}
// Get the preroll timestamp from the MediaSourcePlayer.
base::TimeDelta GetPrerollTimestamp() {
return player_.preroll_timestamp_;
}
// Simulate player has reached starvation timeout.
void TriggerPlayerStarvation() {
player_.decoder_starvation_callback_.Cancel();
player_.OnDecoderStarved();
}
// Release() the player.
void ReleasePlayer() {
EXPECT_TRUE(player_.IsPlaying());
player_.Release();
EXPECT_FALSE(player_.IsPlaying());
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_FALSE(GetMediaDecoderJob(false));
}
// Upon the next successful decode callback, post a task to call Release()
// on the |player_|. TEST_F's do not have access to the private player
// members, hence this helper method.
// Prevent usage creep of MSP::set_decode_callback_for_testing() by
// only using it for the ReleaseWithOnPrefetchDoneAlreadyPosted test.
void OnNextTestDecodeCallbackPostTaskToReleasePlayer() {
player_.set_decode_callback_for_testing(media::BindToLoop(
message_loop_.message_loop_proxy(),
base::Bind(
&MediaSourcePlayerTest::ReleaseWithPendingPrefetchDoneVerification,
base::Unretained(this))));
}
// Asynch test callback posted upon decode completion to verify that a pending
// prefetch done event is cleared across |player_|'s Release(). This helps
// ensure the ReleaseWithOnPrefetchDoneAlreadyPosted test scenario is met.
void ReleaseWithPendingPrefetchDoneVerification() {
EXPECT_TRUE(player_.IsEventPending(player_.PREFETCH_DONE_EVENT_PENDING));
ReleasePlayer();
EXPECT_FALSE(player_.IsEventPending(player_.PREFETCH_DONE_EVENT_PENDING));
EXPECT_FALSE(decoder_callback_hook_executed_);
decoder_callback_hook_executed_ = true;
}
// Inspect internal pending_event_ state of |player_|. This is for infrequent
// use by tests, only where required.
bool IsPendingSurfaceChange() {
return player_.IsEventPending(player_.SURFACE_CHANGE_EVENT_PENDING);
}
DemuxerConfigs CreateAudioDemuxerConfigs(AudioCodec audio_codec) {
DemuxerConfigs configs;
configs.audio_codec = audio_codec;
configs.audio_channels = 2;
configs.is_audio_encrypted = false;
configs.duration_ms = kDefaultDurationInMs;
if (audio_codec == kCodecVorbis) {
configs.audio_sampling_rate = 44100;
scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(
"vorbis-extradata");
configs.audio_extra_data = std::vector<uint8>(
buffer->data(),
buffer->data() + buffer->data_size());
return configs;
}
// Other codecs are not yet supported by this helper.
EXPECT_EQ(audio_codec, kCodecAAC);
configs.audio_sampling_rate = 48000;
uint8 aac_extra_data[] = { 0x13, 0x10 };
configs.audio_extra_data = std::vector<uint8>(
aac_extra_data,
aac_extra_data + 2);
return configs;
}
// Starts an audio decoder job.
void StartAudioDecoderJob() {
Start(CreateAudioDemuxerConfigs(kCodecVorbis));
}
DemuxerConfigs CreateVideoDemuxerConfigs() {
DemuxerConfigs configs;
configs.video_codec = kCodecVP8;
configs.video_size = gfx::Size(320, 240);
configs.is_video_encrypted = false;
configs.duration_ms = kDefaultDurationInMs;
return configs;
}
DemuxerConfigs CreateAudioVideoDemuxerConfigs() {
DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis);
configs.video_codec = kCodecVP8;
configs.video_size = gfx::Size(320, 240);
configs.is_video_encrypted = false;
return configs;
}
void StartVideoDecoderJob() {
Start(CreateVideoDemuxerConfigs());
}
// Starts decoding the data.
void Start(const DemuxerConfigs& configs) {
player_.OnDemuxerConfigsAvailable(configs);
player_.Start();
EXPECT_TRUE(player_.IsPlaying());
}
AccessUnit CreateAccessUnitWithData(bool is_audio, int audio_packet_id) {
AccessUnit unit;
unit.status = DemuxerStream::kOk;
scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(
is_audio ? base::StringPrintf("vorbis-packet-%d", audio_packet_id)
: "vp8-I-frame-320x240");
unit.data = std::vector<uint8>(
buffer->data(), buffer->data() + buffer->data_size());
if (is_audio) {
// Vorbis needs 4 extra bytes padding on Android to decode properly. Check
// NuMediaExtractor.cpp in Android source code.
uint8 padding[4] = { 0xff , 0xff , 0xff , 0xff };
unit.data.insert(unit.data.end(), padding, padding + 4);
}
return unit;
}
DemuxerData CreateReadFromDemuxerAckForAudio(int packet_id) {
DemuxerData data;
data.type = DemuxerStream::AUDIO;
data.access_units.resize(1);
data.access_units[0] = CreateAccessUnitWithData(true, packet_id);
return data;
}
DemuxerData CreateReadFromDemuxerAckForVideo() {
DemuxerData data;
data.type = DemuxerStream::VIDEO;
data.access_units.resize(1);
data.access_units[0] = CreateAccessUnitWithData(false, 0);
return data;
}
DemuxerData CreateEOSAck(bool is_audio) {
DemuxerData data;
data.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
data.access_units.resize(1);
data.access_units[0].status = DemuxerStream::kOk;
data.access_units[0].end_of_stream = true;
return data;
}
DemuxerData CreateAbortedAck(bool is_audio) {
DemuxerData data;
data.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
data.access_units.resize(1);
data.access_units[0].status = DemuxerStream::kAborted;
return data;
}
// Helper method for use at test start. It starts an audio decoder job and
// immediately feeds it some data to decode. Then, without letting the decoder
// job complete a decode cycle, it also starts player SeekTo(). Upon return,
// the player should not yet have sent the DemuxerSeek IPC request, though
// seek event should be pending. The audio decoder job will also still be
// decoding.
void StartAudioDecoderJobAndSeekToWhileDecoding(
const base::TimeDelta& seek_time) {
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_FALSE(player_.IsPlaying());
EXPECT_EQ(0, demuxer_->num_data_requests());
EXPECT_EQ(0.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_EQ(player_.GetCurrentTime(), GetPrerollTimestamp());
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
player_.SeekTo(seek_time);
EXPECT_EQ(0.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
// Seek, including simulated receipt of |kAborted| read between SeekTo()
// and OnDemuxerSeekDone(). Use this helper method only when the player
// already has created the decoder job.
void SeekPlayer(bool is_audio, const base::TimeDelta& seek_time) {
EXPECT_TRUE(GetMediaDecoderJob(is_audio));
int original_num_seeks = demuxer_->num_seek_requests();
int original_num_data_requests = demuxer_->num_data_requests();
// Initiate a seek. Skip the round-trip of requesting seek from renderer.
// Instead behave as if the renderer has asked us to seek.
player_.SeekTo(seek_time);
// Verify that the seek does not occur until previously outstanding data
// request is satisfied.
EXPECT_EQ(original_num_seeks, demuxer_->num_seek_requests());
// Simulate seeking causes the demuxer to abort the outstanding read caused
// by the seek.
player_.OnDemuxerDataAvailable(CreateAbortedAck(is_audio));
// Verify that the seek is requested now that the outstanding read is
// completed by aborted access unit.
EXPECT_EQ(original_num_seeks + 1, demuxer_->num_seek_requests());
// Send back the seek done notification. This should trigger the player to
// call OnReadFromDemuxer() again.
EXPECT_EQ(original_num_data_requests, demuxer_->num_data_requests());
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_EQ(original_num_data_requests + 1, demuxer_->num_data_requests());
// No other seek should have been requested.
EXPECT_EQ(original_num_seeks + 1, demuxer_->num_seek_requests());
}
DemuxerData CreateReadFromDemuxerAckWithConfigChanged(bool is_audio,
int config_unit_index) {
DemuxerData data;
data.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
data.access_units.resize(config_unit_index + 1);
for (int i = 0; i < config_unit_index; ++i)
data.access_units[i] = CreateAccessUnitWithData(is_audio, i);
data.access_units[config_unit_index].status = DemuxerStream::kConfigChanged;
return data;
}
// Valid only for video-only player tests. If |trigger_with_release_start| is
// true, triggers the browser seek with a Release() + video data received +
// Start() with a new surface. If false, triggers the browser seek by
// setting a new video surface after beginning decode of received video data.
// Such data receipt causes possibility that an I-frame is not next, and
// browser seek results once decode completes and surface change processing
// begins.
void BrowserSeekPlayer(bool trigger_with_release_start) {
int expected_num_data_requests = demuxer_->num_data_requests();
int expected_num_seek_requests = demuxer_->num_seek_requests();
int expected_num_browser_seek_requests =
demuxer_->num_browser_seek_requests();
EXPECT_FALSE(GetMediaDecoderJob(false));
CreateNextTextureAndSetVideoSurface();
StartVideoDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(false));
expected_num_data_requests++;
EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
if (trigger_with_release_start) {
ReleasePlayer();
// Simulate demuxer's response to the video data request.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_FALSE(player_.IsPlaying());
EXPECT_EQ(expected_num_seek_requests, demuxer_->num_seek_requests());
EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
CreateNextTextureAndSetVideoSurface();
player_.Start();
} else {
// Simulate demuxer's response to the video data request.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
// While the decoder is decoding, trigger a browser seek by changing
// surface. Demuxer does not know of browser seek in advance, so no
// |kAborted| data is required (though |kAborted| can certainly occur for
// any pending read in reality due to renderer preparing for a regular
// seek).
CreateNextTextureAndSetVideoSurface();
// Browser seek should not begin until decoding has completed.
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(expected_num_seek_requests, demuxer_->num_seek_requests());
EXPECT_EQ(expected_num_browser_seek_requests,
demuxer_->num_browser_seek_requests());
// Wait for the decoder job to finish decoding and be reset pending the
// browser seek.
while (GetMediaDecoderJob(false) &&
GetMediaDecoderJob(false)->is_decoding()) {
message_loop_.RunUntilIdle();
}
}
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_TRUE(player_.IsPlaying());
// Only one browser seek should have been initiated, and no further data
// should have been requested.
expected_num_seek_requests++;
expected_num_browser_seek_requests++;
EXPECT_EQ(expected_num_seek_requests, demuxer_->num_seek_requests());
EXPECT_EQ(expected_num_browser_seek_requests,
demuxer_->num_browser_seek_requests());
EXPECT_EQ(expected_num_data_requests, demuxer_->num_seek_requests());
}
// Creates a new decoder job and feeds it data ending with a |kConfigChanged|
// access unit. If |config_unit_in_prefetch| is true, sends feeds the config
// change AU in response to the job's first read request (prefetch). If
// false, regular data is fed and decoded prior to feeding the config change
// AU in response to the second data request (after prefetch completed).
// |config_unit_index| controls which access unit is |kConfigChanged|.
void StartConfigChange(bool is_audio,
bool config_unit_in_prefetch,
int config_unit_index) {
int expected_num_data_requests = demuxer_->num_data_requests();
int expected_num_config_requests = demuxer_->num_config_requests();
EXPECT_FALSE(GetMediaDecoderJob(is_audio));
if (is_audio) {
StartAudioDecoderJob();
} else {
CreateNextTextureAndSetVideoSurface();
StartVideoDecoderJob();
}
EXPECT_TRUE(GetMediaDecoderJob(is_audio));
expected_num_data_requests++;
EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
EXPECT_EQ(expected_num_config_requests, demuxer_->num_config_requests());
// Feed and decode a standalone access unit so the player exits prefetch.
if (!config_unit_in_prefetch) {
if (is_audio)
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
else
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
message_loop_.Run();
// We should have completed the prefetch phase at this point.
EXPECT_TRUE(GetMediaDecoderJob(is_audio));
expected_num_data_requests++;
EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
EXPECT_EQ(expected_num_config_requests, demuxer_->num_config_requests());
}
// Feed and decode access units with data for any units prior to
// |config_unit_index|, and a |kConfigChanged| unit at that index.
// Player should prepare to reconfigure the decoder job, and should request
// new demuxer configs.
player_.OnDemuxerDataAvailable(
CreateReadFromDemuxerAckWithConfigChanged(is_audio, config_unit_index));
while (GetMediaDecoderJob(is_audio)->is_decoding())
message_loop_.RunUntilIdle();
expected_num_config_requests++;
EXPECT_TRUE(player_.IsPlaying());
EXPECT_TRUE(GetMediaDecoderJob(is_audio));
EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
EXPECT_EQ(expected_num_config_requests, demuxer_->num_config_requests());
}
void CreateNextTextureAndSetVideoSurface() {
gfx::SurfaceTexture* surface_texture;
if (surface_texture_a_is_next_) {
surface_texture_a_ = new gfx::SurfaceTexture(next_texture_id_++);
surface_texture = surface_texture_a_.get();
} else {
surface_texture_b_ = new gfx::SurfaceTexture(next_texture_id_++);
surface_texture = surface_texture_b_.get();
}
surface_texture_a_is_next_ = !surface_texture_a_is_next_;
gfx::ScopedJavaSurface surface = gfx::ScopedJavaSurface(surface_texture);
player_.SetVideoSurface(surface.Pass());
}
base::TimeTicks StartTimeTicks() {
return player_.start_time_ticks_;
}
bool IsTypeSupported(const std::vector<uint8>& scheme_uuid,
const std::string& security_level,
const std::string& container,
const std::vector<std::string>& codecs) {
return MediaSourcePlayer::IsTypeSupported(
scheme_uuid, security_level, container, codecs);
}
base::MessageLoop message_loop_;
MockMediaPlayerManager manager_;
MockDemuxerAndroid* demuxer_; // Owned by |player_|.
MediaSourcePlayer player_;
// Track whether a possibly asynch decoder callback test hook has run.
bool decoder_callback_hook_executed_;
// We need to keep the surface texture while the decoder is actively decoding.
// Otherwise, it may trigger unexpected crashes on some devices. To switch
// surfaces, tests need to create a new surface texture without releasing
// their previous one. In CreateNextTextureAndSetVideoSurface(), we toggle
// between two surface textures, only replacing the N-2 texture. Assumption is
// that no more than N-1 texture is in use by decoder when
// CreateNextTextureAndSetVideoSurface() is called.
scoped_refptr<gfx::SurfaceTexture> surface_texture_a_;
scoped_refptr<gfx::SurfaceTexture> surface_texture_b_;
bool surface_texture_a_is_next_;
int next_texture_id_;
DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerTest);
};
TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithValidConfig) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test audio decoder job will be created when codec is successfully started.
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithInvalidConfig) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test audio decoder job will not be created when failed to start the codec.
DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis);
// Replace with invalid |audio_extra_data|
configs.audio_extra_data.clear();
uint8 invalid_codec_data[] = { 0x00, 0xff, 0xff, 0xff, 0xff };
configs.audio_extra_data.insert(configs.audio_extra_data.begin(),
invalid_codec_data, invalid_codec_data + 4);
Start(configs);
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_EQ(0, demuxer_->num_data_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test video decoder job will be created when surface is valid.
StartVideoDecoderJob();
// Video decoder job will not be created until surface is available.
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(0, demuxer_->num_data_requests());
// Set both an initial and a later video surface without receiving any
// demuxed data yet.
CreateNextTextureAndSetVideoSurface();
MediaDecoderJob* first_job = GetMediaDecoderJob(false);
EXPECT_TRUE(first_job);
CreateNextTextureAndSetVideoSurface();
// Setting another surface will not create a new job until any pending
// read is satisfied (and job is no longer decoding).
EXPECT_EQ(first_job, GetMediaDecoderJob(false));
// No seeks, even on setting surface, should have occurred. (Browser seeks can
// occur on setting surface, but only after previously receiving video data.)
EXPECT_EQ(0, demuxer_->num_seek_requests());
// Note, the decoder job for the second surface set, above, will be created
// only after the pending read is satisfied and decoded, and the resulting
// browser seek is done. See BrowserSeek_* tests for this coverage.
}
TEST_F(MediaSourcePlayerTest, StartVideoCodecWithInvalidSurface) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test video decoder job will be created when surface is valid.
scoped_refptr<gfx::SurfaceTexture> surface_texture(
new gfx::SurfaceTexture(0));
gfx::ScopedJavaSurface surface(surface_texture.get());
StartVideoDecoderJob();
// Video decoder job will not be created until surface is available.
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(0, demuxer_->num_data_requests());
// Release the surface texture.
surface_texture = NULL;
player_.SetVideoSurface(surface.Pass());
// Player should not seek the demuxer on setting initial surface.
EXPECT_EQ(0, demuxer_->num_seek_requests());
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(0, demuxer_->num_data_requests());
}
TEST_F(MediaSourcePlayerTest, ReadFromDemuxerAfterSeek) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decoder job will resend a ReadFromDemuxer request after seek.
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
SeekPlayer(true, base::TimeDelta());
EXPECT_EQ(2, demuxer_->num_data_requests());
}
TEST_F(MediaSourcePlayerTest, SetSurfaceWhileSeeking) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test SetVideoSurface() will not cause an extra seek while the player is
// waiting for demuxer to indicate seek is done.
StartVideoDecoderJob();
// Player is still waiting for SetVideoSurface(), so no request is sent.
EXPECT_EQ(0, demuxer_->num_data_requests());
// Initiate a seek. Skip requesting element seek of renderer.
// Instead behave as if the renderer has asked us to seek.
EXPECT_EQ(0, demuxer_->num_seek_requests());
player_.SeekTo(base::TimeDelta());
EXPECT_EQ(1, demuxer_->num_seek_requests());
CreateNextTextureAndSetVideoSurface();
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(1, demuxer_->num_seek_requests());
// Reconfirm player has not yet requested data.
EXPECT_EQ(0, demuxer_->num_data_requests());
// Send the seek done notification. The player should start requesting data.
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(1, demuxer_->num_data_requests());
// Reconfirm exactly 1 seek request has been made of demuxer, and that it
// was not a browser seek request.
EXPECT_EQ(1, demuxer_->num_seek_requests());
EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
}
TEST_F(MediaSourcePlayerTest, ChangeMultipleSurfaceWhileDecoding) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test MediaSourcePlayer can switch multiple surfaces during decoding.
CreateNextTextureAndSetVideoSurface();
StartVideoDecoderJob();
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
EXPECT_TRUE(GetMediaDecoderJob(false));
// Send the first input chunk.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
// While the decoder is decoding, change multiple surfaces. Pass an empty
// surface first.
gfx::ScopedJavaSurface empty_surface;
player_.SetVideoSurface(empty_surface.Pass());
// Next, pass a new non-empty surface.
CreateNextTextureAndSetVideoSurface();
// Wait for the decoder job to finish decoding and be reset pending a browser
// seek.
while (GetMediaDecoderJob(false) && GetMediaDecoderJob(false)->is_decoding())
message_loop_.RunUntilIdle();
EXPECT_FALSE(GetMediaDecoderJob(false));
// Only one browser seek should have been initiated. No further data request
// should have been processed on |message_loop_| before surface change event
// became pending, above.
EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
EXPECT_EQ(1, demuxer_->num_data_requests());
// Simulate browser seek is done and confirm player requests more data for new
// video decoder job.
player_.OnDemuxerSeekDone(player_.GetCurrentTime());
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, AudioOnlyStartAfterSeekFinish) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test audio decoder job will not start until pending seek event is handled.
DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis);
player_.OnDemuxerConfigsAvailable(configs);
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_EQ(0, demuxer_->num_data_requests());
// Initiate a seek. Skip requesting element seek of renderer.
// Instead behave as if the renderer has asked us to seek.
player_.SeekTo(base::TimeDelta());
EXPECT_EQ(1, demuxer_->num_seek_requests());
player_.Start();
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_EQ(0, demuxer_->num_data_requests());
// Sending back the seek done notification.
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
// Reconfirm exactly 1 seek request has been made of demuxer.
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, VideoOnlyStartAfterSeekFinish) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test video decoder job will not start until pending seek event is handled.
CreateNextTextureAndSetVideoSurface();
DemuxerConfigs configs = CreateVideoDemuxerConfigs();
player_.OnDemuxerConfigsAvailable(configs);
EXPECT_FALSE(GetMediaDecoderJob(false));
// Initiate a seek. Skip requesting element seek of renderer.
// Instead behave as if the renderer has asked us to seek.
player_.SeekTo(base::TimeDelta());
EXPECT_EQ(1, demuxer_->num_seek_requests());
player_.Start();
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(0, demuxer_->num_data_requests());
// Sending back the seek done notification.
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(1, demuxer_->num_data_requests());
// Reconfirm exactly 1 seek request has been made of demuxer.
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, StartImmediatelyAfterPause) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that if the decoding job is not fully stopped after Pause(),
// calling Start() will be a noop.
StartAudioDecoderJob();
MediaDecoderJob* decoder_job = GetMediaDecoderJob(true);
EXPECT_TRUE(decoder_job);
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
// Sending data to player.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
// Decoder job will not immediately stop after Pause() since it is
// running on another thread.
player_.Pause(true);
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
// Nothing happens when calling Start() again.
player_.Start();
// Verify that Start() will not destroy and recreate the decoder job.
EXPECT_EQ(decoder_job, GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
message_loop_.Run();
// The decoder job should finish and a new request will be sent.
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
}
TEST_F(MediaSourcePlayerTest, DecoderJobsCannotStartWithoutAudio) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that when Start() is called, video decoder jobs will wait for audio
// decoder job before start decoding the data.
DemuxerConfigs configs = CreateAudioVideoDemuxerConfigs();
Start(configs);
EXPECT_EQ(0, demuxer_->num_data_requests());
CreateNextTextureAndSetVideoSurface();
// Player should not seek the demuxer on setting initial surface.
EXPECT_EQ(0, demuxer_->num_seek_requests());
MediaDecoderJob* audio_decoder_job = GetMediaDecoderJob(true);
MediaDecoderJob* video_decoder_job = GetMediaDecoderJob(false);
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_FALSE(audio_decoder_job->is_decoding());
EXPECT_FALSE(video_decoder_job->is_decoding());
// Sending video data to player, audio decoder should not start.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
EXPECT_FALSE(video_decoder_job->is_decoding());
// Sending audio data to player, both decoders should start now.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
EXPECT_TRUE(audio_decoder_job->is_decoding());
EXPECT_TRUE(video_decoder_job->is_decoding());
// Reconfirm no seek occurred.
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, StartTimeTicksResetAfterDecoderUnderruns) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test start time ticks will reset after decoder job underruns.
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
// For the first couple chunks, the decoder job may return
// DECODE_FORMAT_CHANGED status instead of DECODE_SUCCEEDED status. Decode
// more frames to guarantee that DECODE_SUCCEEDED will be returned.
for (int i = 0; i < 4; ++i) {
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
message_loop_.Run();
}
// The decoder job should finish and a new request will be sent.
EXPECT_EQ(5, demuxer_->num_data_requests());
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
base::TimeTicks previous = StartTimeTicks();
// Let the decoder timeout and execute the OnDecoderStarved() callback.
base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
EXPECT_TRUE(StartTimeTicks() != base::TimeTicks());
message_loop_.RunUntilIdle();
// Send new data to the decoder so it can finish the currently
// pending decode.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
while (GetMediaDecoderJob(true)->is_decoding())
message_loop_.RunUntilIdle();
// Verify the start time ticks is cleared at this point because the
// player is prefetching.
EXPECT_TRUE(StartTimeTicks() == base::TimeTicks());
// Send new data to the decoder so it can finish prefetching. This should
// reset the start time ticks.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
EXPECT_TRUE(StartTimeTicks() != base::TimeTicks());
base::TimeTicks current = StartTimeTicks();
EXPECT_LE(100.0, (current - previous).InMillisecondsF());
}
TEST_F(MediaSourcePlayerTest, NoRequestForDataAfterInputEOS) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test MediaSourcePlayer will not request for new data after input EOS is
// reached.
CreateNextTextureAndSetVideoSurface();
StartVideoDecoderJob();
// Player should not seek the demuxer on setting initial surface.
EXPECT_EQ(0, demuxer_->num_seek_requests());
EXPECT_EQ(1, demuxer_->num_data_requests());
// Send the first input chunk.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
message_loop_.Run();
EXPECT_EQ(2, demuxer_->num_data_requests());
// Send EOS.
player_.OnDemuxerDataAvailable(CreateEOSAck(false));
message_loop_.Run();
// No more request for data should be made.
EXPECT_EQ(2, demuxer_->num_data_requests());
// Reconfirm no seek request has occurred.
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, ReplayAfterInputEOS) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test MediaSourcePlayer can replay after input EOS is
// reached.
CreateNextTextureAndSetVideoSurface();
StartVideoDecoderJob();
// Player should not seek the demuxer on setting initial surface.
EXPECT_EQ(0, demuxer_->num_seek_requests());
EXPECT_EQ(1, demuxer_->num_data_requests());
// Send the first input chunk.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
message_loop_.Run();
EXPECT_EQ(2, demuxer_->num_data_requests());
// Send EOS.
player_.OnDemuxerDataAvailable(CreateEOSAck(false));
message_loop_.Run();
// No more request for data should be made.
EXPECT_EQ(2, demuxer_->num_data_requests());
// Initiate a seek. Skip requesting element seek of renderer.
// Instead behave as if the renderer has asked us to seek.
player_.SeekTo(base::TimeDelta());
StartVideoDecoderJob();
EXPECT_EQ(1, demuxer_->num_seek_requests());
player_.OnDemuxerSeekDone(kNoTimestamp());
// Seek/Play after EOS should request more data.
EXPECT_EQ(3, demuxer_->num_data_requests());
// Reconfirm only 1 seek request has occurred.
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, FirstDataIsEOS) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decode of EOS buffer without any prior decode. See also
// http://b/11696552.
Start(CreateAudioDemuxerConfigs(kCodecAAC));
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
player_.OnDemuxerDataAvailable(CreateEOSAck(true));
EXPECT_FALSE(manager_.playback_completed());
message_loop_.Run();
EXPECT_TRUE(manager_.playback_completed());
EXPECT_EQ(1, demuxer_->num_data_requests());
}
TEST_F(MediaSourcePlayerTest, FirstDataAfterSeekIsEOS) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decode of EOS buffer, just after seeking, without any prior decode
// (other than the simulated |kAborted| resulting from the seek process.)
// See also http://b/11696552.
Start(CreateAudioDemuxerConfigs(kCodecAAC));
EXPECT_TRUE(GetMediaDecoderJob(true));
SeekPlayer(true, base::TimeDelta());
EXPECT_EQ(2, demuxer_->num_data_requests());
player_.OnDemuxerDataAvailable(CreateEOSAck(true));
EXPECT_FALSE(manager_.playback_completed());
message_loop_.Run();
EXPECT_TRUE(manager_.playback_completed());
EXPECT_EQ(2, demuxer_->num_data_requests());
}
TEST_F(MediaSourcePlayerTest, NoRequestForDataAfterAbort) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that the decoder will not request new data after receiving an aborted
// access unit.
StartAudioDecoderJob();
EXPECT_EQ(1, demuxer_->num_data_requests());
// Send an aborted access unit.
player_.OnDemuxerDataAvailable(CreateAbortedAck(true));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
// Wait for the decoder job to finish decoding.
while (GetMediaDecoderJob(true)->is_decoding())
message_loop_.RunUntilIdle();
// No request will be sent for new data.
EXPECT_EQ(1, demuxer_->num_data_requests());
// No seek requests should have occurred.
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, DemuxerDataArrivesAfterRelease) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that the decoder should not crash if demuxer data arrives after
// Release().
StartAudioDecoderJob();
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_TRUE(GetMediaDecoderJob(true));
ReleasePlayer();
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
// The decoder job should have been released.
EXPECT_FALSE(player_.IsPlaying());
EXPECT_EQ(1, demuxer_->num_data_requests());
// No seek requests should have occurred.
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, BrowserSeek_RegularSeekPendsBrowserSeekDone) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that a browser seek, once started, delays a newly arrived regular
// SeekTo() request's demuxer seek until the browser seek is done.
BrowserSeekPlayer(false);
EXPECT_EQ(1, demuxer_->num_data_requests());
// Simulate renderer requesting a regular seek while browser seek in progress.
player_.SeekTo(base::TimeDelta());
EXPECT_FALSE(GetMediaDecoderJob(false));
// Simulate browser seek is done. Confirm player requests the regular seek,
// still has no video decoder job configured, and has not requested any
// further data since the surface change event became pending in
// BrowserSeekPlayer().
EXPECT_EQ(1, demuxer_->num_seek_requests());
player_.OnDemuxerSeekDone(base::TimeDelta());
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(2, demuxer_->num_seek_requests());
EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
EXPECT_EQ(1, demuxer_->num_data_requests());
// Simulate regular seek is done and confirm player requests more data for
// new video decoder job.
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_EQ(2, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, NoSeekForInitialReleaseAndStart) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that no seek is requested if player Release() + Start() occurs prior
// to receiving any data.
CreateNextTextureAndSetVideoSurface();
StartVideoDecoderJob();
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_TRUE(GetMediaDecoderJob(false));
ReleasePlayer();
// Pass a new non-empty surface.
CreateNextTextureAndSetVideoSurface();
player_.Start();
// TODO(wolenetz/qinmin): Multiple in-flight data requests for same stream
// should be prevented. See http://crbug.com/306314.
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
EXPECT_TRUE(GetMediaDecoderJob(false));
}
TEST_F(MediaSourcePlayerTest, BrowserSeek_MidStreamReleaseAndStart) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that one browser seek is requested if player Release() + Start(), with
// video data received between Release() and Start().
BrowserSeekPlayer(true);
EXPECT_EQ(1, demuxer_->num_data_requests());
// Simulate browser seek is done and confirm player requests more data.
player_.OnDemuxerSeekDone(base::TimeDelta());
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, PrerollAudioAfterSeek) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decoder job will preroll the media to the seek position.
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
SeekPlayer(true, base::TimeDelta::FromMilliseconds(100));
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
// Send some data before the seek position.
for (int i = 1; i < 4; ++i) {
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
message_loop_.Run();
}
EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_TRUE(IsPrerolling(true));
// Send data after the seek position.
DemuxerData data = CreateReadFromDemuxerAckForAudio(3);
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(100);
player_.OnDemuxerDataAvailable(data);
message_loop_.Run();
EXPECT_LT(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_FALSE(IsPrerolling(true));
}
TEST_F(MediaSourcePlayerTest, PrerollVideoAfterSeek) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decoder job will preroll the media to the seek position.
CreateNextTextureAndSetVideoSurface();
StartVideoDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(1, demuxer_->num_data_requests());
SeekPlayer(false, base::TimeDelta::FromMilliseconds(100));
EXPECT_TRUE(IsPrerolling(false));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
// Send some data before the seek position.
DemuxerData data;
for (int i = 1; i < 4; ++i) {
data = CreateReadFromDemuxerAckForVideo();
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(i * 30);
player_.OnDemuxerDataAvailable(data);
EXPECT_TRUE(GetMediaDecoderJob(false)->is_decoding());
message_loop_.Run();
}
EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_TRUE(IsPrerolling(false));
// Send data at the seek position.
data = CreateReadFromDemuxerAckForVideo();
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(100);
player_.OnDemuxerDataAvailable(data);
message_loop_.Run();
// TODO(wolenetz/qinmin): Player's maintenance of current time for video-only
// streams depends on decoder output, which may be initially inaccurate, and
// encoded video test data may also need updating. Verify at least that AU
// timestamp-based preroll logic has determined video preroll has completed.
EXPECT_FALSE(IsPrerolling(false));
}
TEST_F(MediaSourcePlayerTest, SeekingAfterCompletingPrerollRestartsPreroll) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decoder job will begin prerolling upon seek, when it was not
// prerolling prior to the seek.
StartAudioDecoderJob();
MediaDecoderJob* decoder_job = GetMediaDecoderJob(true);
EXPECT_TRUE(decoder_job);
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_TRUE(IsPrerolling(true));
// Complete the initial preroll by feeding data to the decoder.
for (int i = 0; i < 4; ++i) {
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
message_loop_.Run();
}
EXPECT_LT(0.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_FALSE(IsPrerolling(true));
SeekPlayer(true, base::TimeDelta::FromMilliseconds(500));
// Prerolling should have begun again.
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(500.0, GetPrerollTimestamp().InMillisecondsF());
// Send data at and after the seek position. Prerolling should complete.
for (int i = 0; i < 4; ++i) {
DemuxerData data = CreateReadFromDemuxerAckForAudio(i);
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(
500 + 30 * (i - 1));
player_.OnDemuxerDataAvailable(data);
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
message_loop_.Run();
}
EXPECT_LT(500.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_FALSE(IsPrerolling(true));
// Throughout this test, we should have not re-created the decoder job, so
// IsPrerolling() transition from false to true was not due to constructor
// initialization. It was due to BeginPrerolling().
EXPECT_EQ(decoder_job, GetMediaDecoderJob(true));
}
TEST_F(MediaSourcePlayerTest, PrerollContinuesAcrossReleaseAndStart) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decoder job will resume media prerolling if interrupted by Release()
// and Start().
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
SeekPlayer(true, base::TimeDelta::FromMilliseconds(100));
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
// Send some data before the seek position.
// Test uses 'large' number of iterations because decoder job may not get
// MEDIA_CODEC_OK output status until after a few dequeue output attempts.
// This allows decoder status to stabilize prior to AU timestamp reaching
// the preroll target.
DemuxerData data;
for (int i = 0; i < 10; ++i) {
data = CreateReadFromDemuxerAckForAudio(3);
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(i * 10);
if (i == 1) {
// While still prerolling, Release() and Start() the player.
// TODO(qinmin): Simulation of multiple in-flight data requests (one from
// before Release(), one from after Start()) is not included here, and
// neither is any data enqueued for later decode if it arrives after
// Release() and before Start(). See http://crbug.com/306314. Assumption
// for this test, to prevent flakiness until the bug is fixed, is the
// first request's data arrives before Start(). Though that data is not
// seen by decoder, this assumption allows preroll continuation
// verification and prevents multiple in-flight data requests.
ReleasePlayer();
player_.OnDemuxerDataAvailable(data);
message_loop_.RunUntilIdle();
EXPECT_FALSE(GetMediaDecoderJob(true));
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
} else {
player_.OnDemuxerDataAvailable(data);
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
message_loop_.Run();
}
EXPECT_TRUE(IsPrerolling(true));
}
EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_TRUE(IsPrerolling(true));
// Send data after the seek position.
data = CreateReadFromDemuxerAckForAudio(3);
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(100);
player_.OnDemuxerDataAvailable(data);
message_loop_.Run();
EXPECT_LT(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_FALSE(IsPrerolling(true));
}
TEST_F(MediaSourcePlayerTest, PrerollContinuesAcrossConfigChange) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decoder job will resume media prerolling if interrupted by
// |kConfigChanged| and OnDemuxerConfigsAvailable().
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
SeekPlayer(true, base::TimeDelta::FromMilliseconds(100));
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
// In response to data request, simulate that demuxer signals config change by
// sending an AU with |kConfigChanged|. Player should prepare to reconfigure
// the audio decoder job, and should request new demuxer configs.
DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(true, 0);
EXPECT_EQ(0, demuxer_->num_config_requests());
player_.OnDemuxerDataAvailable(data);
EXPECT_EQ(1, demuxer_->num_config_requests());
// Simulate arrival of new configs.
player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
// Send some data before the seek position.
for (int i = 1; i < 4; ++i) {
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
message_loop_.Run();
}
EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_TRUE(IsPrerolling(true));
// Send data after the seek position.
data = CreateReadFromDemuxerAckForAudio(3);
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(100);
player_.OnDemuxerDataAvailable(data);
message_loop_.Run();
EXPECT_LT(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_FALSE(IsPrerolling(true));
}
TEST_F(MediaSourcePlayerTest, SimultaneousAudioVideoConfigChange) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that the player allows simultaneous audio and video config change,
// such as might occur during OnPrefetchDone() if next access unit for both
// audio and video jobs is |kConfigChanged|.
Start(CreateAudioVideoDemuxerConfigs());
CreateNextTextureAndSetVideoSurface();
MediaDecoderJob* first_audio_job = GetMediaDecoderJob(true);
MediaDecoderJob* first_video_job = GetMediaDecoderJob(false);
EXPECT_TRUE(first_audio_job && first_video_job);
// Simulate audio |kConfigChanged| prefetched as standalone access unit.
player_.OnDemuxerDataAvailable(
CreateReadFromDemuxerAckWithConfigChanged(true, 0));
EXPECT_EQ(0, demuxer_->num_config_requests()); // No OnPrefetchDone() yet.
// Simulate video |kConfigChanged| prefetched as standalone access unit.
player_.OnDemuxerDataAvailable(
CreateReadFromDemuxerAckWithConfigChanged(false, 0));
EXPECT_EQ(1, demuxer_->num_config_requests()); // OnPrefetchDone() occurred.
EXPECT_EQ(2, demuxer_->num_data_requests());
// No job re-creation should occur until the requested configs arrive.
EXPECT_EQ(first_audio_job, GetMediaDecoderJob(true));
EXPECT_EQ(first_video_job, GetMediaDecoderJob(false));
player_.OnDemuxerConfigsAvailable(CreateAudioVideoDemuxerConfigs());
EXPECT_EQ(4, demuxer_->num_data_requests());
MediaDecoderJob* second_audio_job = GetMediaDecoderJob(true);
MediaDecoderJob* second_video_job = GetMediaDecoderJob(false);
EXPECT_NE(first_audio_job, second_audio_job);
EXPECT_NE(first_video_job, second_video_job);
EXPECT_TRUE(second_audio_job && second_video_job);
// Confirm no further demuxer configs requested.
EXPECT_EQ(1, demuxer_->num_config_requests());
}
TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInPrefetchUnit0) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that the player detects need for and requests demuxer configs if
// the |kConfigChanged| unit is the very first unit in the set of units
// received in OnDemuxerDataAvailable() ostensibly while
// |PREFETCH_DONE_EVENT_PENDING|.
StartConfigChange(true, true, 0);
}
TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInPrefetchUnit1) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that the player detects need for and requests demuxer configs if
// the |kConfigChanged| unit is not the first unit in the set of units
// received in OnDemuxerDataAvailable() ostensibly while
// |PREFETCH_DONE_EVENT_PENDING|.
StartConfigChange(true, true, 1);
}
TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInUnit0AfterPrefetch) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that the player detects need for and requests demuxer configs if
// the |kConfigChanged| unit is the very first unit in the set of units
// received in OnDemuxerDataAvailable() from data requested ostensibly while
// not prefetching.
StartConfigChange(true, false, 0);
}
TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInUnit1AfterPrefetch) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that the player detects need for and requests demuxer configs if
// the |kConfigChanged| unit is not the first unit in the set of units
// received in OnDemuxerDataAvailable() from data requested ostensibly while
// not prefetching.
StartConfigChange(true, false, 1);
}
TEST_F(MediaSourcePlayerTest, BrowserSeek_PrerollAfterBrowserSeek) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test decoder job will preroll the media to the actual seek position
// resulting from a browser seek.
BrowserSeekPlayer(false);
// Simulate browser seek is done, but to a later time than was requested.
EXPECT_LT(player_.GetCurrentTime().InMillisecondsF(), 100);
player_.OnDemuxerSeekDone(base::TimeDelta::FromMilliseconds(100));
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_EQ(2, demuxer_->num_data_requests());
// Send some data with access unit timestamps before the actual browser seek
// position. This is a bit unrealistic in this case where the browser seek
// jumped forward and next data from demuxer would normally begin at this
// browser seek position, immediately completing preroll. For simplicity and
// coverage, this test simulates the more common condition that AUs received
// after browser seek begin with timestamps before the seek target, and don't
// immediately complete preroll.
DemuxerData data;
for (int i = 1; i < 4; ++i) {
data = CreateReadFromDemuxerAckForVideo();
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(i * 30);
player_.OnDemuxerDataAvailable(data);
EXPECT_TRUE(GetMediaDecoderJob(false)->is_decoding());
message_loop_.Run();
EXPECT_TRUE(IsPrerolling(false));
}
EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
// Send data after the browser seek position.
data = CreateReadFromDemuxerAckForVideo();
data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(120);
player_.OnDemuxerDataAvailable(data);
message_loop_.Run();
EXPECT_FALSE(IsPrerolling(false));
}
TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChange) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that video config change notification results in request for demuxer
// configuration, and that a video decoder job results without any browser
// seek necessary once the new demuxer config arrives.
StartConfigChange(false, true, 1);
MediaDecoderJob* first_job = GetMediaDecoderJob(false);
EXPECT_TRUE(first_job);
EXPECT_EQ(1, demuxer_->num_data_requests());
EXPECT_EQ(1, demuxer_->num_config_requests());
// Simulate arrival of new configs.
player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs());
// New video decoder job should have been created and configured, without any
// browser seek.
MediaDecoderJob* second_job = GetMediaDecoderJob(false);
EXPECT_TRUE(second_job);
EXPECT_NE(first_job, second_job);
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_EQ(1, demuxer_->num_config_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, VideoConfigChangeContinuesAcrossSeek) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if a demuxer config request is pending (due to previously receiving
// |kConfigChanged|), and a seek request arrives prior to demuxer configs,
// then seek is processed first, followed by the decoder config change.
// This assumes the demuxer sends |kConfigChanged| read response prior to
// canceling any reads pending seek; no |kAborted| is involved in this test.
StartConfigChange(false, false, 1);
MediaDecoderJob* first_job = GetMediaDecoderJob(false);
EXPECT_TRUE(first_job);
EXPECT_EQ(1, demuxer_->num_config_requests());
EXPECT_EQ(2, demuxer_->num_data_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
player_.SeekTo(base::TimeDelta::FromMilliseconds(100));
// Verify that the seek is requested immediately.
EXPECT_EQ(1, demuxer_->num_seek_requests());
// Simulate unlikely delayed arrival of the demuxer configs, completing the
// config change.
// TODO(wolenetz): Is it even possible for requested demuxer configs to be
// delayed until after a SeekTo request arrives?
player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs());
MediaDecoderJob* second_job = GetMediaDecoderJob(false);
EXPECT_NE(first_job, second_job);
EXPECT_TRUE(second_job);
// Send back the seek done notification. This should finish the seek and
// trigger the player to request more data.
EXPECT_EQ(2, demuxer_->num_data_requests());
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_EQ(3, demuxer_->num_data_requests());
}
TEST_F(MediaSourcePlayerTest, NewSurfaceWhileChangingConfigs) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that no seek or duplicated demuxer config request results from a
// SetVideoSurface() that occurs while the player is expecting new demuxer
// configs. This test may be good to keep beyond browser seek hack.
StartConfigChange(false, false, 1);
MediaDecoderJob* first_job = GetMediaDecoderJob(false);
EXPECT_TRUE(first_job);
EXPECT_EQ(1, demuxer_->num_config_requests());
EXPECT_EQ(2, demuxer_->num_data_requests());
CreateNextTextureAndSetVideoSurface();
// Surface change processing (including decoder job re-creation) should
// not occur until the pending video config change is completed.
EXPECT_EQ(first_job, GetMediaDecoderJob(false));
player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs());
MediaDecoderJob* second_job = GetMediaDecoderJob(false);
EXPECT_NE(first_job, second_job);
EXPECT_TRUE(second_job);
EXPECT_EQ(3, demuxer_->num_data_requests());
EXPECT_EQ(1, demuxer_->num_config_requests());
EXPECT_EQ(0, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, ReleaseWithOnPrefetchDoneAlreadyPosted) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if OnPrefetchDone() had already been posted before and is executed
// after Release(), then player does not DCHECK. This test is fragile to
// change to MediaDecoderJob::Prefetch() implementation; it assumes task
// is posted to run |prefetch_cb| if the job already HasData().
// TODO(wolenetz): Remove MSP::set_decode_callback_for_testing() if this test
// becomes obsolete. See http://crbug.com/304234.
StartAudioDecoderJob();
// Escape the original prefetch by decoding a single access unit.
player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
message_loop_.Run();
// Prime the job with a few more access units, so that a later prefetch,
// triggered by starvation to simulate decoder underrun, can trivially
// post task to run OnPrefetchDone().
player_.OnDemuxerDataAvailable(
CreateReadFromDemuxerAckWithConfigChanged(true, 4));
EXPECT_TRUE(GetMediaDecoderJob(true) &&
GetMediaDecoderJob(true)->is_decoding());
// Simulate decoder underrun, so trivial prefetch starts while still decoding.
// The prefetch and posting of OnPrefetchDone() will not occur until next
// MediaDecoderCallBack() occurs.
TriggerPlayerStarvation();
// Upon the next successful decode callback, post a task to call Release() on
// the |player_|, such that the trivial OnPrefetchDone() task posting also
// occurs and should execute after the Release().
OnNextTestDecodeCallbackPostTaskToReleasePlayer();
while (GetMediaDecoderJob(true))
message_loop_.RunUntilIdle();
EXPECT_TRUE(decoder_callback_hook_executed_);
EXPECT_EQ(2, demuxer_->num_data_requests());
// Player should have no decoder job until after Start().
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
}
TEST_F(MediaSourcePlayerTest, SeekToThenReleaseThenDemuxerSeekAndDone) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if Release() occurs after SeekTo(), but the DemuxerSeek IPC request
// has not yet been sent, then the seek request is sent after Release(). Also,
// test if OnDemuxerSeekDone() occurs prior to next Start(), then the player
// will resume correct post-seek preroll upon Start().
StartAudioDecoderJobAndSeekToWhileDecoding(
base::TimeDelta::FromMilliseconds(100));
ReleasePlayer();
EXPECT_EQ(1, demuxer_->num_seek_requests());
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_FALSE(player_.IsPlaying());
// Player should begin prefetch and resume preroll upon Start().
EXPECT_EQ(1, demuxer_->num_data_requests());
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further seek should have been requested since Release(), above.
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, SeekToThenReleaseThenDemuxerSeekThenStart) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if Release() occurs after SeekTo(), but the DemuxerSeek IPC request
// has not yet been sent, then the seek request is sent after Release(). Also,
// test if OnDemuxerSeekDone() does not occur until after the next Start(),
// then the player remains pending seek done until (and resumes correct
// post-seek preroll after) OnDemuxerSeekDone().
StartAudioDecoderJobAndSeekToWhileDecoding(
base::TimeDelta::FromMilliseconds(100));
ReleasePlayer();
EXPECT_EQ(1, demuxer_->num_seek_requests());
// Player should not prefetch upon Start() nor create the decoder job, due to
// awaiting DemuxerSeekDone.
StartAudioDecoderJob();
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further seek should have been requested since Release(), above.
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, SeekToThenDemuxerSeekThenReleaseThenSeekDone) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if Release() occurs after a SeekTo()'s subsequent DemuxerSeek IPC
// request and OnDemuxerSeekDone() arrives prior to the next Start(), then the
// player will resume correct post-seek preroll upon Start().
StartAudioDecoderJobAndSeekToWhileDecoding(
base::TimeDelta::FromMilliseconds(100));
while (GetMediaDecoderJob(true)->is_decoding())
message_loop_.RunUntilIdle();
EXPECT_EQ(1, demuxer_->num_seek_requests());
ReleasePlayer();
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_FALSE(player_.IsPlaying());
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
// Player should begin prefetch and resume preroll upon Start().
EXPECT_EQ(1, demuxer_->num_data_requests());
StartAudioDecoderJob();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further seek should have been requested since before Release(), above.
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, SeekToThenReleaseThenStart) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if Release() occurs after a SeekTo()'s subsequent DemuxerSeeK IPC
// request OnDemuxerSeekDone() does not occur until after the next Start(),
// then the player remains pending seek done until (and resumes correct
// post-seek preroll after) OnDemuxerSeekDone().
StartAudioDecoderJobAndSeekToWhileDecoding(
base::TimeDelta::FromMilliseconds(100));
while (GetMediaDecoderJob(true)->is_decoding())
message_loop_.RunUntilIdle();
EXPECT_EQ(1, demuxer_->num_seek_requests());
ReleasePlayer();
StartAudioDecoderJob();
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
player_.OnDemuxerSeekDone(kNoTimestamp());
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_TRUE(IsPrerolling(true));
EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further seek should have been requested since before Release(), above.
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, ConfigChangedThenReleaseThenConfigsAvailable) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if Release() occurs after |kConfigChanged| detected, new configs
// requested of demuxer, and the requested configs arrive before the next
// Start(), then the player completes the pending config change processing on
// their receipt.
StartConfigChange(true, true, 0);
ReleasePlayer();
player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_FALSE(player_.IsPlaying());
EXPECT_EQ(1, demuxer_->num_data_requests());
// Player should resume upon Start(), even without further configs supplied.
player_.Start();
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_TRUE(player_.IsPlaying());
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further config request should have occurred since StartConfigChange().
EXPECT_EQ(1, demuxer_->num_config_requests());
}
TEST_F(MediaSourcePlayerTest, ConfigChangedThenReleaseThenStart) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test if Release() occurs after |kConfigChanged| detected, new configs
// requested of demuxer, and the requested configs arrive after the next
// Start(), then the player pends job creation until the new configs arrive.
StartConfigChange(true, true, 0);
ReleasePlayer();
player_.Start();
EXPECT_TRUE(player_.IsPlaying());
EXPECT_FALSE(GetMediaDecoderJob(true));
EXPECT_EQ(1, demuxer_->num_data_requests());
player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
EXPECT_TRUE(GetMediaDecoderJob(true));
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further config request should have occurred since StartConfigChange().
EXPECT_EQ(1, demuxer_->num_config_requests());
}
TEST_F(MediaSourcePlayerTest, BrowserSeek_ThenReleaseThenDemuxerSeekDone) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that Release() after a browser seek's DemuxerSeek IPC request has been
// sent behaves similar to a regular seek: if OnDemuxerSeekDone() occurs
// before the next Start()+SetVideoSurface(), then the player will resume
// correct post-seek preroll upon Start()+SetVideoSurface().
BrowserSeekPlayer(false);
base::TimeDelta expected_preroll_timestamp = player_.GetCurrentTime();
ReleasePlayer();
player_.OnDemuxerSeekDone(expected_preroll_timestamp);
EXPECT_FALSE(player_.IsPlaying());
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
// Player should begin prefetch and resume preroll upon Start().
EXPECT_EQ(1, demuxer_->num_data_requests());
StartVideoDecoderJob();
CreateNextTextureAndSetVideoSurface();
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_TRUE(IsPrerolling(false));
EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
EXPECT_EQ(expected_preroll_timestamp, player_.GetCurrentTime());
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further seek should have been requested since BrowserSeekPlayer().
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
TEST_F(MediaSourcePlayerTest, BrowserSeek_ThenReleaseThenStart) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that Release() after a browser seek's DemuxerSeek IPC request has been
// sent behaves similar to a regular seek: if OnDemuxerSeekDone() does not
// occur until after the next Start()+SetVideoSurface(), then the player
// remains pending seek done until (and resumes correct post-seek preroll
// after) OnDemuxerSeekDone().
BrowserSeekPlayer(false);
base::TimeDelta expected_preroll_timestamp = player_.GetCurrentTime();
ReleasePlayer();
StartVideoDecoderJob();
CreateNextTextureAndSetVideoSurface();
EXPECT_FALSE(GetMediaDecoderJob(false));
EXPECT_EQ(1, demuxer_->num_data_requests());
player_.OnDemuxerSeekDone(expected_preroll_timestamp);
EXPECT_TRUE(GetMediaDecoderJob(false));
EXPECT_TRUE(IsPrerolling(false));
EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
EXPECT_EQ(expected_preroll_timestamp, player_.GetCurrentTime());
EXPECT_EQ(2, demuxer_->num_data_requests());
// No further seek should have been requested since BrowserSeekPlayer().
EXPECT_EQ(1, demuxer_->num_seek_requests());
}
// TODO(xhwang): Once we add tests to cover DrmBridge, update this test to
// also verify that the job is successfully created if SetDrmBridge(), Start()
// and eventually OnMediaCrypto() occur. This would increase test coverage of
// http://crbug.com/313470 and allow us to remove inspection of internal player
// pending event state. See http://crbug.com/313860.
TEST_F(MediaSourcePlayerTest, SurfaceChangeClearedEvenIfMediaCryptoAbsent) {
SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
// Test that |SURFACE_CHANGE_EVENT_PENDING| is not pending after
// SetVideoSurface() for a player configured for encrypted video, when the
// player has not yet received media crypto.
DemuxerConfigs configs = CreateVideoDemuxerConfigs();
configs.is_video_encrypted = true;
player_.OnDemuxerConfigsAvailable(configs);
CreateNextTextureAndSetVideoSurface();
EXPECT_FALSE(IsPendingSurfaceChange());
EXPECT_FALSE(GetMediaDecoderJob(false));
}
// TODO(xhwang): Enable this test when the test devices are updated.
TEST_F(MediaSourcePlayerTest, DISABLED_IsTypeSupported_Widevine) {
if (!MediaCodecBridge::IsAvailable() || !MediaDrmBridge::IsAvailable()) {
VLOG(0) << "Could not run test - not supported on device.";
return;
}
uint8 kWidevineUUID[] = { 0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
std::vector<uint8> widevine_uuid(kWidevineUUID,
kWidevineUUID + arraysize(kWidevineUUID));
// We test "L3" fully. But for "L1" we don't check the result as it depend on
// whether the test device supports "L1" decoding.
std::vector<std::string> codec_avc(1, "avc1");
std::vector<std::string> codec_aac(1, "mp4a");
std::vector<std::string> codec_avc_aac(1, "avc1");
codec_avc_aac.push_back("mp4a");
EXPECT_TRUE(IsTypeSupported(widevine_uuid, "L3", kVideoMp4, codec_avc));
IsTypeSupported(widevine_uuid, "L1", kVideoMp4, codec_avc);
// TODO(xhwang): L1/L3 doesn't apply to audio, so the result is messy.
// Clean this up after we have a solution to specifying decoding mode.
EXPECT_TRUE(IsTypeSupported(widevine_uuid, "L3", kAudioMp4, codec_aac));
IsTypeSupported(widevine_uuid, "L1", kAudioMp4, codec_aac);
EXPECT_TRUE(IsTypeSupported(widevine_uuid, "L3", kVideoMp4, codec_avc_aac));
IsTypeSupported(widevine_uuid, "L1", kVideoMp4, codec_avc_aac);
std::vector<std::string> codec_vp8(1, "vp8");
std::vector<std::string> codec_vorbis(1, "vorbis");
std::vector<std::string> codec_vp8_vorbis(1, "vp8");
codec_vp8_vorbis.push_back("vorbis");
// TODO(xhwang): WebM is actually not supported but currently
// MediaDrmBridge.isCryptoSchemeSupported() doesn't check the container type.
// Fix isCryptoSchemeSupported() and update this test as necessary.
EXPECT_TRUE(IsTypeSupported(widevine_uuid, "L3", kVideoWebM, codec_vp8));
IsTypeSupported(widevine_uuid, "L1", kVideoWebM, codec_vp8);
// TODO(xhwang): L1/L3 doesn't apply to audio, so the result is messy.
// Clean this up after we have a solution to specifying decoding mode.
EXPECT_TRUE(IsTypeSupported(widevine_uuid, "L3", kAudioWebM, codec_vorbis));
IsTypeSupported(widevine_uuid, "L1", kAudioWebM, codec_vorbis);
EXPECT_TRUE(
IsTypeSupported(widevine_uuid, "L3", kVideoWebM, codec_vp8_vorbis));
IsTypeSupported(widevine_uuid, "L1", kVideoWebM, codec_vp8_vorbis);
}
TEST_F(MediaSourcePlayerTest, IsTypeSupported_InvalidUUID) {
if (!MediaCodecBridge::IsAvailable() || !MediaDrmBridge::IsAvailable()) {
VLOG(0) << "Could not run test - not supported on device.";
return;
}
uint8 kInvalidUUID[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
std::vector<uint8> invalid_uuid(kInvalidUUID,
kInvalidUUID + arraysize(kInvalidUUID));
std::vector<std::string> codec_avc(1, "avc1");
EXPECT_FALSE(IsTypeSupported(invalid_uuid, "L3", kVideoMp4, codec_avc));
EXPECT_FALSE(IsTypeSupported(invalid_uuid, "L1", kVideoMp4, codec_avc));
}
// TODO(xhwang): Are these IsTypeSupported tests device specific?
// TODO(xhwang): Add more IsTypeSupported tests.
} // namespace media
|