1// Copyright 2014 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 "media/formats/mp2t/es_parser_test_base.h"
6
7#include "base/files/memory_mapped_file.h"
8#include "base/logging.h"
9#include "base/path_service.h"
10#include "base/strings/string_util.h"
11#include "media/base/buffers.h"
12#include "media/base/stream_parser_buffer.h"
13#include "media/base/test_data_util.h"
14#include "media/formats/mp2t/es_parser.h"
15#include "testing/gtest/include/gtest/gtest.h"
16
17namespace media {
18namespace mp2t {
19
20EsParserTestBase::Packet::Packet()
21    : offset(0u),
22      size(0u),
23      pts(kNoTimestamp()) {
24}
25
26EsParserTestBase::EsParserTestBase()
27    : config_count_(0u),
28      buffer_count_(0u) {
29}
30
31EsParserTestBase::~EsParserTestBase() {
32}
33
34void EsParserTestBase::LoadStream(const char* filename) {
35  base::FilePath file_path = GetTestDataFilePath(filename);
36
37  base::MemoryMappedFile stream;
38  ASSERT_TRUE(stream.Initialize(file_path))
39      << "Couldn't open stream file: " << file_path.MaybeAsASCII();
40
41  stream_.resize(stream.length());
42  memcpy(&stream_[0], stream.data(), stream_.size());
43}
44
45void EsParserTestBase::NewAudioConfig(const AudioDecoderConfig& config) {
46  config_count_++;
47}
48
49void EsParserTestBase::NewVideoConfig(const VideoDecoderConfig& config) {
50  config_count_++;
51}
52
53void EsParserTestBase::EmitBuffer(scoped_refptr<StreamParserBuffer> buffer) {
54  buffer_timestamps_stream_ << "("
55                            << buffer->timestamp().InMilliseconds()
56                            << ") ";
57  buffer_count_++;
58}
59
60bool EsParserTestBase::ProcessPesPackets(
61    EsParser* es_parser,
62    const std::vector<Packet>& pes_packets,
63    bool force_timing) {
64  DCHECK(es_parser);
65
66  buffer_count_ = 0;
67  config_count_ = 0;
68  buffer_timestamps_stream_.str(std::string());
69
70  for (size_t k = 0; k < pes_packets.size(); k++) {
71    size_t cur_pes_offset = pes_packets[k].offset;
72    size_t cur_pes_size = pes_packets[k].size;
73
74    base::TimeDelta pts = kNoTimestamp();
75    DecodeTimestamp dts = kNoDecodeTimestamp();
76    if (pes_packets[k].pts >= base::TimeDelta() || force_timing)
77      pts = pes_packets[k].pts;
78
79    DCHECK_LT(cur_pes_offset, stream_.size());
80    if (!es_parser->Parse(&stream_[cur_pes_offset], cur_pes_size, pts, dts))
81      return false;
82  }
83  es_parser->Flush();
84
85  buffer_timestamps_ = buffer_timestamps_stream_.str();
86  base::TrimWhitespaceASCII(
87      buffer_timestamps_, base::TRIM_ALL, &buffer_timestamps_);
88  return true;
89}
90
91void EsParserTestBase::ComputePacketSize(std::vector<Packet>* packets) {
92  DCHECK(packets);
93  if (packets->size() == 0u)
94    return;
95
96  Packet* cur = &(*packets)[0];
97  for (size_t k = 0; k < packets->size() - 1; k++) {
98    Packet* next = &(*packets)[k + 1];
99    DCHECK_GE(next->offset, cur->offset);
100    cur->size = next->offset - cur->offset;
101    cur = next;
102  }
103  DCHECK_GE(stream_.size(), cur->offset);
104  cur->size = stream_.size() - cur->offset;
105}
106
107std::vector<EsParserTestBase::Packet>
108EsParserTestBase::GenerateFixedSizePesPacket(size_t pes_size) {
109  DCHECK_GT(stream_.size(), 0u);
110  std::vector<Packet> pes_packets;
111
112  Packet cur_pes_packet;
113  cur_pes_packet.offset = 0;
114  cur_pes_packet.pts = kNoTimestamp();
115  while (cur_pes_packet.offset < stream_.size()) {
116    pes_packets.push_back(cur_pes_packet);
117    cur_pes_packet.offset += pes_size;
118  }
119  ComputePacketSize(&pes_packets);
120
121  return pes_packets;
122}
123
124}  // namespace mp2t
125}  // namespace media
126