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 "media/mp2t/ts_section_pes.h"
6
7#include "base/logging.h"
8#include "base/strings/string_number_conversions.h"
9#include "media/base/bit_reader.h"
10#include "media/base/buffers.h"
11#include "media/mp2t/es_parser.h"
12#include "media/mp2t/mp2t_common.h"
13
14static const int kPesStartCode = 0x000001;
15
16// Given that |time| is coded using 33 bits,
17// UnrollTimestamp returns the corresponding unrolled timestamp.
18// The unrolled timestamp is defined by:
19// |time| + k * (2 ^ 33)
20// where k is estimated so that the unrolled timestamp
21// is as close as possible to |previous_unrolled_time|.
22static int64 UnrollTimestamp(int64 previous_unrolled_time, int64 time) {
23  // Mpeg2 TS timestamps have an accuracy of 33 bits.
24  const int nbits = 33;
25
26  // |timestamp| has a precision of |nbits|
27  // so make sure the highest bits are set to 0.
28  DCHECK_EQ((time >> nbits), 0);
29
30  // Consider 3 possibilities to estimate the missing high bits of |time|.
31  int64 previous_unrolled_time_high =
32      (previous_unrolled_time >> nbits);
33  int64 time0 = ((previous_unrolled_time_high - 1) << nbits) | time;
34  int64 time1 = ((previous_unrolled_time_high + 0) << nbits) | time;
35  int64 time2 = ((previous_unrolled_time_high + 1) << nbits) | time;
36
37  // Select the min absolute difference with the current time
38  // so as to ensure time continuity.
39  int64 diff0 = time0 - previous_unrolled_time;
40  int64 diff1 = time1 - previous_unrolled_time;
41  int64 diff2 = time2 - previous_unrolled_time;
42  if (diff0 < 0)
43    diff0 = -diff0;
44  if (diff1 < 0)
45    diff1 = -diff1;
46  if (diff2 < 0)
47    diff2 = -diff2;
48
49  int64 unrolled_time;
50  int64 min_diff;
51  if (diff1 < diff0) {
52    unrolled_time = time1;
53    min_diff = diff1;
54  } else {
55    unrolled_time = time0;
56    min_diff = diff0;
57  }
58  if (diff2 < min_diff)
59    unrolled_time = time2;
60
61  return unrolled_time;
62}
63
64static bool IsTimestampSectionValid(int64 timestamp_section) {
65  // |pts_section| has 40 bits:
66  // - starting with either '0010' or '0011' or '0001'
67  // - and ending with a marker bit.
68  // See ITU H.222 standard - PES section.
69
70  // Verify that all the marker bits are set to one.
71  return ((timestamp_section & 0x1) != 0) &&
72         ((timestamp_section & 0x10000) != 0) &&
73         ((timestamp_section & 0x100000000) != 0);
74}
75
76static int64 ConvertTimestampSectionToTimestamp(int64 timestamp_section) {
77  return (((timestamp_section >> 33) & 0x7) << 30) |
78         (((timestamp_section >> 17) & 0x7fff) << 15) |
79         (((timestamp_section >> 1) & 0x7fff) << 0);
80}
81
82namespace media {
83namespace mp2t {
84
85TsSectionPes::TsSectionPes(scoped_ptr<EsParser> es_parser)
86  : es_parser_(es_parser.release()),
87    wait_for_pusi_(true),
88    previous_pts_valid_(false),
89    previous_pts_(0),
90    previous_dts_valid_(false),
91    previous_dts_(0) {
92  DCHECK(es_parser_);
93}
94
95TsSectionPes::~TsSectionPes() {
96}
97
98bool TsSectionPes::Parse(bool payload_unit_start_indicator,
99                             const uint8* buf, int size) {
100  // Ignore partial PES.
101  if (wait_for_pusi_ && !payload_unit_start_indicator)
102    return true;
103
104  bool parse_result = true;
105  if (payload_unit_start_indicator) {
106    // Try emitting a packet since we might have a pending PES packet
107    // with an undefined size.
108    // In this case, a unit is emitted when the next unit is coming.
109    int raw_pes_size;
110    const uint8* raw_pes;
111    pes_byte_queue_.Peek(&raw_pes, &raw_pes_size);
112    if (raw_pes_size > 0)
113      parse_result = Emit(true);
114
115    // Reset the state.
116    ResetPesState();
117
118    // Update the state.
119    wait_for_pusi_ = false;
120  }
121
122  // Add the data to the parser state.
123  if (size > 0)
124    pes_byte_queue_.Push(buf, size);
125
126  // Try emitting the current PES packet.
127  return (parse_result && Emit(false));
128}
129
130void TsSectionPes::Flush() {
131  // Try emitting a packet since we might have a pending PES packet
132  // with an undefined size.
133  Emit(true);
134
135  // Flush the underlying ES parser.
136  es_parser_->Flush();
137}
138
139void TsSectionPes::Reset() {
140  ResetPesState();
141
142  previous_pts_valid_ = false;
143  previous_pts_ = 0;
144  previous_dts_valid_ = false;
145  previous_dts_ = 0;
146
147  es_parser_->Reset();
148}
149
150bool TsSectionPes::Emit(bool emit_for_unknown_size) {
151  int raw_pes_size;
152  const uint8* raw_pes;
153  pes_byte_queue_.Peek(&raw_pes, &raw_pes_size);
154
155  // A PES should be at least 6 bytes.
156  // Wait for more data to come if not enough bytes.
157  if (raw_pes_size < 6)
158    return true;
159
160  // Check whether we have enough data to start parsing.
161  int pes_packet_length =
162      (static_cast<int>(raw_pes[4]) << 8) |
163      (static_cast<int>(raw_pes[5]));
164  if ((pes_packet_length == 0 && !emit_for_unknown_size) ||
165      (pes_packet_length != 0 && raw_pes_size < pes_packet_length + 6)) {
166    // Wait for more data to come either because:
167    // - there are not enough bytes,
168    // - or the PES size is unknown and the "force emit" flag is not set.
169    //   (PES size might be unknown for video PES packet).
170    return true;
171  }
172  DVLOG(LOG_LEVEL_PES) << "pes_packet_length=" << pes_packet_length;
173
174  // Parse the packet.
175  bool parse_result = ParseInternal(raw_pes, raw_pes_size);
176
177  // Reset the state.
178  ResetPesState();
179
180  return parse_result;
181}
182
183bool TsSectionPes::ParseInternal(const uint8* raw_pes, int raw_pes_size) {
184  BitReader bit_reader(raw_pes, raw_pes_size);
185
186  // Read up to the pes_packet_length (6 bytes).
187  int packet_start_code_prefix;
188  int stream_id;
189  int pes_packet_length;
190  RCHECK(bit_reader.ReadBits(24, &packet_start_code_prefix));
191  RCHECK(bit_reader.ReadBits(8, &stream_id));
192  RCHECK(bit_reader.ReadBits(16, &pes_packet_length));
193
194  RCHECK(packet_start_code_prefix == kPesStartCode);
195  DVLOG(LOG_LEVEL_PES) << "stream_id=" << std::hex << stream_id << std::dec;
196  if (pes_packet_length == 0)
197    pes_packet_length = bit_reader.bits_available() / 8;
198
199  // Ignore the PES for unknown stream IDs.
200  // See ITU H.222 Table 2-22 "Stream_id assignments"
201  bool is_audio_stream_id = ((stream_id & 0xe0) == 0xc0);
202  bool is_video_stream_id = ((stream_id & 0xf0) == 0xe0);
203  if (!is_audio_stream_id && !is_video_stream_id)
204    return true;
205
206  // Read up to "pes_header_data_length".
207  int dummy_2;
208  int PES_scrambling_control;
209  int PES_priority;
210  int data_alignment_indicator;
211  int copyright;
212  int original_or_copy;
213  int pts_dts_flags;
214  int escr_flag;
215  int es_rate_flag;
216  int dsm_trick_mode_flag;
217  int additional_copy_info_flag;
218  int pes_crc_flag;
219  int pes_extension_flag;
220  int pes_header_data_length;
221  RCHECK(bit_reader.ReadBits(2, &dummy_2));
222  RCHECK(dummy_2 == 0x2);
223  RCHECK(bit_reader.ReadBits(2, &PES_scrambling_control));
224  RCHECK(bit_reader.ReadBits(1, &PES_priority));
225  RCHECK(bit_reader.ReadBits(1, &data_alignment_indicator));
226  RCHECK(bit_reader.ReadBits(1, &copyright));
227  RCHECK(bit_reader.ReadBits(1, &original_or_copy));
228  RCHECK(bit_reader.ReadBits(2, &pts_dts_flags));
229  RCHECK(bit_reader.ReadBits(1, &escr_flag));
230  RCHECK(bit_reader.ReadBits(1, &es_rate_flag));
231  RCHECK(bit_reader.ReadBits(1, &dsm_trick_mode_flag));
232  RCHECK(bit_reader.ReadBits(1, &additional_copy_info_flag));
233  RCHECK(bit_reader.ReadBits(1, &pes_crc_flag));
234  RCHECK(bit_reader.ReadBits(1, &pes_extension_flag));
235  RCHECK(bit_reader.ReadBits(8, &pes_header_data_length));
236  int pes_header_start_size = bit_reader.bits_available() / 8;
237
238  // Compute the size and the offset of the ES payload.
239  // "6" for the 6 bytes read before and including |pes_packet_length|.
240  // "3" for the 3 bytes read before and including |pes_header_data_length|.
241  int es_size = pes_packet_length - 3 - pes_header_data_length;
242  int es_offset = 6 + 3 + pes_header_data_length;
243  RCHECK(es_size >= 0);
244  RCHECK(es_offset + es_size <= raw_pes_size);
245
246  // Read the timing information section.
247  bool is_pts_valid = false;
248  bool is_dts_valid = false;
249  int64 pts_section = 0;
250  int64 dts_section = 0;
251  if (pts_dts_flags == 0x2) {
252    RCHECK(bit_reader.ReadBits(40, &pts_section));
253    RCHECK((((pts_section >> 36) & 0xf) == 0x2) &&
254           IsTimestampSectionValid(pts_section));
255    is_pts_valid = true;
256  }
257  if (pts_dts_flags == 0x3) {
258    RCHECK(bit_reader.ReadBits(40, &pts_section));
259    RCHECK(bit_reader.ReadBits(40, &dts_section));
260    RCHECK((((pts_section >> 36) & 0xf) == 0x3) &&
261           IsTimestampSectionValid(pts_section));
262    RCHECK((((dts_section >> 36) & 0xf) == 0x1) &&
263           IsTimestampSectionValid(dts_section));
264    is_pts_valid = true;
265    is_dts_valid = true;
266  }
267
268  // Convert and unroll the timestamps.
269  base::TimeDelta media_pts(kNoTimestamp());
270  base::TimeDelta media_dts(kNoTimestamp());
271  if (is_pts_valid) {
272    int64 pts = ConvertTimestampSectionToTimestamp(pts_section);
273    if (previous_pts_valid_)
274      pts = UnrollTimestamp(previous_pts_, pts);
275    previous_pts_ = pts;
276    previous_pts_valid_ = true;
277    media_pts = base::TimeDelta::FromMicroseconds((1000 * pts) / 90);
278  }
279  if (is_dts_valid) {
280    int64 dts = ConvertTimestampSectionToTimestamp(dts_section);
281    if (previous_dts_valid_)
282      dts = UnrollTimestamp(previous_dts_, dts);
283    previous_dts_ = dts;
284    previous_dts_valid_ = true;
285    media_dts = base::TimeDelta::FromMicroseconds((1000 * dts) / 90);
286  }
287
288  // Discard the rest of the PES packet header.
289  // TODO(damienv): check if some info of the PES packet header are useful.
290  DCHECK_EQ(bit_reader.bits_available() % 8, 0);
291  int pes_header_remaining_size = pes_header_data_length -
292      (pes_header_start_size - bit_reader.bits_available() / 8);
293  RCHECK(pes_header_remaining_size >= 0);
294
295  // Read the PES packet.
296  DVLOG(LOG_LEVEL_PES)
297      << "Emit a reassembled PES:"
298      << " size=" << es_size
299      << " pts=" << media_pts.InMilliseconds()
300      << " dts=" << media_dts.InMilliseconds()
301      << " data_alignment_indicator=" << data_alignment_indicator;
302  return es_parser_->Parse(&raw_pes[es_offset], es_size, media_pts, media_dts);
303}
304
305void TsSectionPes::ResetPesState() {
306  pes_byte_queue_.Reset();
307  wait_for_pusi_ = true;
308}
309
310}  // namespace mp2t
311}  // namespace media
312
313