chromium/media/formats/webm/cluster_builder.cc

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "media/formats/webm/cluster_builder.h"

#include <memory>
#include <utility>

#include "base/check_op.h"
#include "media/base/data_buffer.h"
#include "media/formats/webm/webm_constants.h"

namespace media {

static const uint8_t kClusterHeader[] = …;

static const uint8_t kSimpleBlockHeader[] = …;

static const uint8_t kBlockGroupHeader[] = …;

static const uint8_t kBlockGroupHeaderWithoutBlockDuration[] = …;

static const uint8_t kBlockGroupReferenceBlock[] = …;

enum { … };

Cluster::Cluster(base::HeapArray<uint8_t> data, int bytes_used)
    : … { … }
Cluster::~Cluster() = default;

ClusterBuilder::ClusterBuilder() { … }
ClusterBuilder::~ClusterBuilder() = default;

void ClusterBuilder::SetClusterTimecode(int64_t cluster_timecode) { … }

void ClusterBuilder::AddSimpleBlock(int track_num,
                                    int64_t timecode,
                                    int flags,
                                    const uint8_t* data,
                                    int size) { … }

void ClusterBuilder::AddBlockGroup(int track_num,
                                   int64_t timecode,
                                   int duration,
                                   int flags,
                                   bool is_key_frame,
                                   const uint8_t* data,
                                   int size) { … }

void ClusterBuilder::AddBlockGroupWithoutBlockDuration(int track_num,
                                                       int64_t timecode,
                                                       int flags,
                                                       bool is_key_frame,
                                                       const uint8_t* data,
                                                       int size) { … }

void ClusterBuilder::AddBlockGroupInternal(int track_num,
                                           int64_t timecode,
                                           bool include_block_duration,
                                           int duration,
                                           int flags,
                                           bool is_key_frame,
                                           const uint8_t* data,
                                           int size) { … }

void ClusterBuilder::WriteBlock(uint8_t* buf,
                                int track_num,
                                int64_t timecode,
                                int flags,
                                const uint8_t* data,
                                int size) { … }

std::unique_ptr<Cluster> ClusterBuilder::Finish() { … }

std::unique_ptr<Cluster> ClusterBuilder::FinishWithUnknownSize() { … }

void ClusterBuilder::Reset() { … }

void ClusterBuilder::ExtendBuffer(size_t bytes_needed) { … }

void ClusterBuilder::UpdateUInt64(int offset, int64_t value) { … }

}  // namespace media