mp4_movie_box_writer.cc | Explore in Territory

// Copyright 2023 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/muxers/mp4_movie_box_writer.h"

#include <memory>
#include <string>
#include <vector>

#include "base/big_endian.h"
#include "base/numerics/safe_conversions.h"
#include "media/base/audio_timestamp_helper.h"
#include "media/formats/mp4/es_descriptor.h"
#include "media/muxers/box_byte_stream.h"
#include "media/muxers/mp4_muxer_context.h"
#include "media/muxers/mp4_type_conversion.h"
#include "media/muxers/output_position_tracker.h"

namespace media {

namespace {

// ISO/IEC 14496-12.
// A transformation matrix for the video.
// Video frames are not scaled, rotated, or skewed, and are displayed at
// their original size with no zoom or depth applied.

// The value 0x00010000 in the top-left and middle element of the
// matrix specifies the horizontal and vertical scaling factor,
// respectively. This means that the video frames are not scaled and
// are displayed at their original size.

// The bottom-right element of the matrix, with a value of 0x40000000,
// specifies the fixed-point value of the zoom or depth of the video frames.
// This value is equal to 1.0 in decimal notation, meaning that there
// is no zoom or depth applied to the video frames.
constexpr int32_t kDisplayIdentityMatrix[9] = …;

void WriteIsoTime(BoxByteStream& writer, base::Time time) { … }

void WriteLowHigh(BoxByteStream& writer, uint32_t value) { … }

}  // namespace

// Mp4FileTypeBoxWriter class.
Mp4FileTypeBoxWriter::Mp4FileTypeBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::FileType& box)
    : … { … }

Mp4FileTypeBoxWriter::~Mp4FileTypeBoxWriter() = default;

void Mp4FileTypeBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieBoxWriter class.
Mp4MovieBoxWriter::Mp4MovieBoxWriter(const Mp4MuxerContext& context,
                                     const mp4::writable_boxes::Movie& box)
    : … { … }

Mp4MovieBoxWriter::~Mp4MovieBoxWriter() = default;

void Mp4MovieBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieHeaderBoxWriter class.
Mp4MovieHeaderBoxWriter::Mp4MovieHeaderBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::MovieHeader& box)
    : … { … }

Mp4MovieHeaderBoxWriter::~Mp4MovieHeaderBoxWriter() = default;

void Mp4MovieHeaderBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieExtendsBoxWriter (`mvex`) class.
Mp4MovieExtendsBoxWriter::Mp4MovieExtendsBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::MovieExtends& box)
    : … { … }

Mp4MovieExtendsBoxWriter::~Mp4MovieExtendsBoxWriter() = default;

void Mp4MovieExtendsBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieTrackExtendsBoxWriter (`trex`) class.
Mp4MovieTrackExtendsBoxWriter::Mp4MovieTrackExtendsBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::TrackExtends& box)
    : … { … }

Mp4MovieTrackExtendsBoxWriter::~Mp4MovieTrackExtendsBoxWriter() = default;

void Mp4MovieTrackExtendsBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieTrackBoxWriter (`trak`) class.
Mp4MovieTrackBoxWriter::Mp4MovieTrackBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::Track& box)
    : … { … }

Mp4MovieTrackBoxWriter::~Mp4MovieTrackBoxWriter() = default;

void Mp4MovieTrackBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieTrackHeaderBoxWriter (`tkhd`) class.
Mp4MovieTrackHeaderBoxWriter::Mp4MovieTrackHeaderBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::TrackHeader& box)
    : … { … }

Mp4MovieTrackHeaderBoxWriter::~Mp4MovieTrackHeaderBoxWriter() = default;

void Mp4MovieTrackHeaderBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieMediaBoxWriter (`mdia`) class.
Mp4MovieMediaBoxWriter::Mp4MovieMediaBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::Media& box)
    : … { … }

Mp4MovieMediaBoxWriter::~Mp4MovieMediaBoxWriter() = default;

void Mp4MovieMediaBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieMediaHeaderBoxWriter (`mdhd`) class.
Mp4MovieMediaHeaderBoxWriter::Mp4MovieMediaHeaderBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::MediaHeader& box)
    : … { … }

Mp4MovieMediaHeaderBoxWriter::~Mp4MovieMediaHeaderBoxWriter() = default;

void Mp4MovieMediaHeaderBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieMediaHandlerBoxWriter (`hdlr`) class.
Mp4MovieMediaHandlerBoxWriter::Mp4MovieMediaHandlerBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::MediaHandler& box)
    : … { … }

Mp4MovieMediaHandlerBoxWriter::~Mp4MovieMediaHandlerBoxWriter() = default;

void Mp4MovieMediaHandlerBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieMediaInformationBoxWriter (`minf`) class.
Mp4MovieMediaInformationBoxWriter::Mp4MovieMediaInformationBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::MediaInformation& box)
    : … { … }

Mp4MovieMediaInformationBoxWriter::~Mp4MovieMediaInformationBoxWriter() =
    default;

void Mp4MovieMediaInformationBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieVideoHeaderBoxWriter (`vmhd`) class.
Mp4MovieVideoHeaderBoxWriter::Mp4MovieVideoHeaderBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MovieVideoHeaderBoxWriter::~Mp4MovieVideoHeaderBoxWriter() = default;

void Mp4MovieVideoHeaderBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieSoundHeaderBoxWriter (`smhd`) class.
Mp4MovieSoundHeaderBoxWriter::Mp4MovieSoundHeaderBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MovieSoundHeaderBoxWriter::~Mp4MovieSoundHeaderBoxWriter() = default;

void Mp4MovieSoundHeaderBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieDataInformationBoxWriter (`dinf`) class.
Mp4MovieDataInformationBoxWriter::Mp4MovieDataInformationBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::DataInformation& box)
    : … { … }

Mp4MovieDataInformationBoxWriter::~Mp4MovieDataInformationBoxWriter() = default;

void Mp4MovieDataInformationBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieDataReferenceBoxWriter (`dref`) class.
Mp4MovieDataReferenceBoxWriter::Mp4MovieDataReferenceBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::DataReference& box)
    : … { … }

Mp4MovieDataReferenceBoxWriter::~Mp4MovieDataReferenceBoxWriter() = default;

void Mp4MovieDataReferenceBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieDataUrlEntryBoxWriter (`url`) class.
Mp4MovieDataUrlEntryBoxWriter::Mp4MovieDataUrlEntryBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MovieDataUrlEntryBoxWriter::~Mp4MovieDataUrlEntryBoxWriter() = default;

void Mp4MovieDataUrlEntryBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieSampleTableBoxWriter (`stbl`) class.
Mp4MovieSampleTableBoxWriter::Mp4MovieSampleTableBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::SampleTable& box)
    : … { … }

Mp4MovieSampleTableBoxWriter::~Mp4MovieSampleTableBoxWriter() = default;

void Mp4MovieSampleTableBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieSampleToChunkBoxWriter (`stsc`) class.
Mp4MovieSampleToChunkBoxWriter::Mp4MovieSampleToChunkBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MovieSampleToChunkBoxWriter::~Mp4MovieSampleToChunkBoxWriter() = default;

void Mp4MovieSampleToChunkBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieDecodingTimeToSampleBoxWriter (`stts`) class.
Mp4MovieDecodingTimeToSampleBoxWriter::Mp4MovieDecodingTimeToSampleBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MovieDecodingTimeToSampleBoxWriter::
    ~Mp4MovieDecodingTimeToSampleBoxWriter() = default;

void Mp4MovieDecodingTimeToSampleBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieSampleSizeBoxWriter (`stsz`) class.
Mp4MovieSampleSizeBoxWriter::Mp4MovieSampleSizeBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MovieSampleSizeBoxWriter::~Mp4MovieSampleSizeBoxWriter() = default;

void Mp4MovieSampleSizeBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieSampleChunkOffsetBoxWriter (`stco`) class.
Mp4MovieSampleChunkOffsetBoxWriter::Mp4MovieSampleChunkOffsetBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MovieSampleChunkOffsetBoxWriter::~Mp4MovieSampleChunkOffsetBoxWriter() =
    default;

void Mp4MovieSampleChunkOffsetBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieSampleDescriptionBoxWriter (`stsd`) class.
Mp4MovieSampleDescriptionBoxWriter::Mp4MovieSampleDescriptionBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::SampleDescription& box)
    : … { … }

Mp4MovieSampleDescriptionBoxWriter::~Mp4MovieSampleDescriptionBoxWriter() =
    default;

void Mp4MovieSampleDescriptionBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieVisualSampleEntryBoxWriter (`avc1`, 'vp09') class.
Mp4MovieVisualSampleEntryBoxWriter::Mp4MovieVisualSampleEntryBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::VisualSampleEntry& box)
    : … { … }

Mp4MovieVisualSampleEntryBoxWriter::~Mp4MovieVisualSampleEntryBoxWriter() =
    default;

void Mp4MovieVisualSampleEntryBoxWriter::Write(BoxByteStream& writer) { … }

#if BUILDFLAG(USE_PROPRIETARY_CODECS)
// Mp4MovieAVCDecoderConfigurationBoxWriter (`avcC`) class.
Mp4MovieAVCDecoderConfigurationBoxWriter::
    Mp4MovieAVCDecoderConfigurationBoxWriter(
        const Mp4MuxerContext& context,
        const mp4::writable_boxes::AVCDecoderConfiguration& box)
    : Mp4BoxWriter(context), box_(box) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}

Mp4MovieAVCDecoderConfigurationBoxWriter::
    ~Mp4MovieAVCDecoderConfigurationBoxWriter() = default;

void Mp4MovieAVCDecoderConfigurationBoxWriter::Write(BoxByteStream& writer) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  writer.StartBox(mp4::FOURCC_AVCC);

  std::vector<uint8_t> write_data;
  CHECK(box_->avc_config_record.Serialize(write_data));

  writer.WriteBytes(write_data.data(), write_data.size());

  writer.EndBox();
}

// Mp4MovieElementaryStreamDescriptorBoxWriter (`esds`) class.
Mp4MovieElementaryStreamDescriptorBoxWriter::
    Mp4MovieElementaryStreamDescriptorBoxWriter(
        const Mp4MuxerContext& context,
        const mp4::writable_boxes::ElementaryStreamDescriptor& box)
    : Mp4BoxWriter(context), box_(box) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}

Mp4MovieElementaryStreamDescriptorBoxWriter::
    ~Mp4MovieElementaryStreamDescriptorBoxWriter() = default;

void Mp4MovieElementaryStreamDescriptorBoxWriter::Write(BoxByteStream& writer) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  writer.StartFullBox(mp4::FOURCC_ESDS);

  std::vector<uint8_t> esds =
      mp4::ESDescriptor::CreateEsds(box_->aac_codec_description);
  writer.WriteBytes(esds.data(), esds.size());

  writer.EndBox();
}
#endif

// Mp4MovieAudioSampleEntryBoxWriter (`mp4a` or 'Opus') class.
Mp4MovieAudioSampleEntryBoxWriter::Mp4MovieAudioSampleEntryBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::AudioSampleEntry& box)
    : … { … }

Mp4MovieAudioSampleEntryBoxWriter::~Mp4MovieAudioSampleEntryBoxWriter() =
    default;

void Mp4MovieAudioSampleEntryBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieOpusSpecificBoxWriter (`dOps`) class.
Mp4MovieOpusSpecificBoxWriter::Mp4MovieOpusSpecificBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::OpusSpecificBox& box)
    : … { … }

Mp4MovieOpusSpecificBoxWriter::~Mp4MovieOpusSpecificBoxWriter() = default;

void Mp4MovieOpusSpecificBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieVPCodecConfigurationBoxWriter (`vpcC`) class.
Mp4MovieVPCodecConfigurationBoxWriter::Mp4MovieVPCodecConfigurationBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::VPCodecConfiguration& box)
    : … { … }

Mp4MovieVPCodecConfigurationBoxWriter::
    ~Mp4MovieVPCodecConfigurationBoxWriter() = default;

void Mp4MovieVPCodecConfigurationBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieAV1CodecConfigurationBoxWriter (`vpcC`) class.
Mp4MovieAV1CodecConfigurationBoxWriter::Mp4MovieAV1CodecConfigurationBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::AV1CodecConfiguration& box)
    : … { … }

Mp4MovieAV1CodecConfigurationBoxWriter::
    ~Mp4MovieAV1CodecConfigurationBoxWriter() = default;

void Mp4MovieAV1CodecConfigurationBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MoviePixelAspectRatioBoxBoxWriter (`pasp`) class.
Mp4MoviePixelAspectRatioBoxBoxWriter::Mp4MoviePixelAspectRatioBoxBoxWriter(
    const Mp4MuxerContext& context)
    : … { … }

Mp4MoviePixelAspectRatioBoxBoxWriter::~Mp4MoviePixelAspectRatioBoxBoxWriter() =
    default;

void Mp4MoviePixelAspectRatioBoxBoxWriter::Write(BoxByteStream& writer) { … }

// Mp4MovieBitRateBoxWriter (`btrt`) class.
Mp4MovieBitRateBoxWriter::Mp4MovieBitRateBoxWriter(
    const Mp4MuxerContext& context,
    const mp4::writable_boxes::BitRate& box)
    : … { … }

Mp4MovieBitRateBoxWriter::~Mp4MovieBitRateBoxWriter() = default;

void Mp4MovieBitRateBoxWriter::Write(BoxByteStream& writer) { … }

}  // namespace media
chromium/media/muxers/mp4_movie_box_writer.cc
