The Tor Browser: comparison content/media/encoder/fmp4

--1:000000000000
+:76757869c271
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef ISOCOMPOSITOR_H_
+#define ISOCOMPOSITOR_H_
+#include "mozilla/Endian.h"
+#include "nsTArray.h"
+#include "ISOTrackMetadata.h"
+#include "EncodedFrameContainer.h"
+namespace mozilla {
+class Box;
+class ISOControl;
+/**
+* This class collects elementary stream data to form a fragment.
+* ISOMediaWriter will check if the data is enough; if yes, the corresponding
+* moof will be created and write to ISOControl.
+* Each audio and video has its own fragment and only one during the whole
+* life cycle, when a fragment is formed in ISOControl, Flush() needs to
+* be called to reset it.
+*/
+class FragmentBuffer {
+public:
+// aTrackType: it could be Audio_Track or Video_Track.
+// aFragDuration: it is the fragment duration. (microsecond per unit)
+//                Audio and video have the same fragment duration.
+FragmentBuffer(uint32_t aTrackType, uint32_t aFragDuration);
+~FragmentBuffer();
+// Get samples of first fragment, that will swap all the elements in the
+// mFragArray[0] when aFlush = true, and caller is responsible for drop
+// EncodedFrame reference count.
+nsresult GetFirstFragment(nsTArray<nsRefPtr<EncodedFrame>>& aFragment,
+bool aFlush = false);
+// Add sample frame to the last element fragment of mFragArray. If sample
+// number is enough, it will append a new fragment element. And the new
+// sample will be added to the new fragment element of mFragArray.
+nsresult AddFrame(EncodedFrame* aFrame);
+// Get total sample size of first complete fragment size.
+uint32_t GetFirstFragmentSampleSize();
+// Get sample number of first complete fragment.
+uint32_t GetFirstFragmentSampleNumber();
+// Check if it accumulates enough frame data.
+// It returns true when data is enough to form a fragment.
+bool HasEnoughData();
+// Called by ISOMediaWriter when TrackEncoder has sent the last frame. The
+// remains frame data will form the last moof and move the state machine to
+// in ISOMediaWriter to last phrase.
+nsresult SetEndOfStream() {
+mEOS = true;
+return  NS_OK;
+}
+bool EOS() { return mEOS; }
+// CSD (codec specific data), it is generated by encoder and the data depends
+// on codec type. This data will be sent as a special frame from encoder to
+// ISOMediaWriter and pass to this class via AddFrame().
+nsresult GetCSD(nsTArray<uint8_t>& aCSD);
+bool HasCSD() { return mCSDFrame; }
+uint32_t GetType() { return mTrackType; }
+void SetLastFragmentLastFrameTime(uint32_t aTime) {
+mLastFrameTimeOfLastFragment = aTime;
+}
+uint32_t GetLastFragmentLastFrameTime() {
+return mLastFrameTimeOfLastFragment;
+}
+private:
+uint32_t mTrackType;
+// Fragment duration, microsecond per unit.
+uint32_t mFragDuration;
+// Media start time, microsecond per unit.
+// Together with mFragDuration, mFragmentNumber and EncodedFrame->GetTimeStamp(),
+// when the difference between current frame time and mMediaStartTime is
+// exceeded current fragment ceiling timeframe, that means current fragment has
+// enough data and a new element in mFragArray will be added.
+uint64_t mMediaStartTime;
+// Current fragment number. It will be increase when a new element of
+// mFragArray is created.
+// Note:
+//   It only means the fragment number of current accumulated frames, not
+//   the current 'creating' fragment mFragNum in ISOControl.
+uint32_t mFragmentNumber;
+// The last frame time stamp of last fragment. It is for calculating the
+// play duration of first frame in current fragment. The frame duration is
+// defined as "current frame timestamp - last frame timestamp" here. So it
+// needs to keep the last timestamp of last fragment.
+uint32_t mLastFrameTimeOfLastFragment;
+// Array of fragments, each element has enough samples to form a
+// complete fragment.
+nsTArray<nsTArray<nsRefPtr<EncodedFrame>>> mFragArray;
+// Codec specific data frame, it will be generated by encoder and send to
+// ISOMediaWriter through WriteEncodedTrack(). The data will be vary depends
+// on codec type.
+nsRefPtr<EncodedFrame> mCSDFrame;
+// END_OF_STREAM from ContainerWriter
+bool mEOS;
+};
+/**
+* ISOControl will be carried to each box when box is created. It is the main
+* bridge for box to output stream to ContainerWriter and retrieve information.
+* ISOControl acts 3 different roles:
+* 1. Holds the pointer of audio metadata, video metadata, fragment and
+*    pass them to boxes.
+* 2. Provide the functions to generate the base structure of MP4; they are
+*    GenerateFtyp, GenerateMoov, GenerateMoof, and GenerateMfra.
+* 3. The actually writer used by MuxOperation::Write() in each box. It provides
+*    writing methods for different kind of data; they are Write, WriteArray,
+*    WriteBits...etc.
+*/
+class ISOControl {
+friend class Box;
+public:
+ISOControl(uint32_t aMuxingType);
+~ISOControl();
+nsresult GenerateFtyp();
+nsresult GenerateMoov();
+nsresult GenerateMoof(uint32_t aTrackType);
+// Swap elementary stream pointer to output buffers.
+uint32_t WriteAVData(nsTArray<uint8_t>& aArray);
+uint32_t Write(uint8_t* aBuf, uint32_t aSize);
+uint32_t Write(uint8_t aData);
+template <typename T>
+uint32_t Write(T aData) {
+MOZ_ASSERT(!mBitCount);
+aData = NativeEndian::swapToNetworkOrder(aData);
+Write((uint8_t*)&aData, sizeof(T));
+return sizeof(T);
+}
+template <typename T>
+uint32_t WriteArray(const T &aArray, uint32_t aSize) {
+MOZ_ASSERT(!mBitCount);
+uint32_t size = 0;
+for (uint32_t i = 0; i < aSize; i++) {
+size += Write(aArray[i]);
+}
+return size;
+}
+uint32_t WriteFourCC(const char* aType);
+// Bit writing. Note: it needs to be byte-boundary before using
+// others non-bit writing function.
+uint32_t WriteBits(uint64_t aBits, size_t aNumBits);
+// This is called by GetContainerData and swap all the buffers to aOutputBuffers.
+nsresult GetBufs(nsTArray<nsTArray<uint8_t>>* aOutputBufs);
+// Presentation time in seconds since midnight, Jan. 1, 1904, in UTC time.
+uint32_t GetTime();
+// current fragment number
+uint32_t GetCurFragmentNumber() { return mFragNum; }
+nsresult SetFragment(FragmentBuffer* aFragment);
+FragmentBuffer* GetFragment(uint32_t aType);
+uint32_t GetMuxingType() { return mMuxingType; }
+nsresult SetMetadata(TrackMetadataBase* aTrackMeta);
+nsresult GetAudioMetadata(nsRefPtr<AudioTrackMetadata>& aAudMeta);
+nsresult GetVideoMetadata(nsRefPtr<VideoTrackMetadata>& aVidMeta);
+// Track ID is the Metadata index in mMetaArray. It allows only 1 audio
+// track and 1 video track in this muxer. In this muxer, it is prohibt to have
+// mutiple audio track or video track in the same file.
+uint32_t GetTrackID(TrackMetadataBase::MetadataKind aKind);
+uint32_t GetNextTrackID();
+bool HasAudioTrack();
+bool HasVideoTrack();
+private:
+uint32_t GetBufPos();
+nsresult FlushBuf();
+// One of value in TYPE_XXX, defined in ISOMediaWriter.
+uint32_t mMuxingType;
+// Audio and video fragments are owned by ISOMediaWriter.
+// They don't need to worry about pointer going stale because ISOMediaWriter's
+// lifetime is longer than ISOControl.
+FragmentBuffer* mAudioFragmentBuffer;
+FragmentBuffer* mVideoFragmentBuffer;
+// Generated fragment number
+uint32_t mFragNum;
+// The (index + 1) will be the track ID.
+nsTArray<nsRefPtr<TrackMetadataBase>> mMetaArray;
+// Array of output buffers.
+// To save memory usage, audio/video sample will be swapped into a new element
+// of this array.
+//
+// For example,
+//   mOutBuffers[0] --> boxes (allocated by muxer)
+//   mOutBuffers[1] --> video raw data (allocated by encoder)
+//   mOutBuffers[2] --> video raw data (allocated by encoder)
+//   mOutBuffers[3] --> video raw data (allocated by encoder)
+//   mOutBuffers[4] --> boxes (allocated by muxer)
+//   mOutBuffers[5] --> audio raw data (allocated by encoder)
+//   ...etc.
+//
+nsTArray<nsTArray<uint8_t>> mOutBuffers;
+// Accumulate output size from Write().
+uint64_t mOutputSize;
+// Bit writing operation. Note: the mBitCount should be 0 before any
+// byte-boundary writing method be called (Write(uint32_t), Write(uint16_t)...etc);
+// otherwise, there will be assertion on these functions.
+uint8_t mBitCount;
+uint8_t mBit;
+};
+}
+#endif

The Tor Browser / file comparison

comparison: content/media/encoder/fmp4_muxer/ISOControl.h

content/media/encoder/fmp4_muxer/ISOControl.h