mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-07 12:15:51 +00:00
67411f1d5e
Timestamp Offset calculations are now done exclusively by the Media Source components which allow to recalculate them on the fly. By abstracting those offsets it remove the need for the sub-decoders to handle them (which allows to add WebM support).
298 lines
11 KiB
C++
298 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/. */
|
|
#if !defined(MediaData_h)
|
|
#define MediaData_h
|
|
|
|
#include "nsSize.h"
|
|
#include "mozilla/gfx/Rect.h"
|
|
#include "nsRect.h"
|
|
#include "AudioSampleFormat.h"
|
|
#include "nsIMemoryReporter.h"
|
|
#include "SharedBuffer.h"
|
|
#include "nsRefPtr.h"
|
|
#include "nsTArray.h"
|
|
|
|
namespace mozilla {
|
|
|
|
namespace layers {
|
|
class Image;
|
|
class ImageContainer;
|
|
}
|
|
|
|
// Container that holds media samples.
|
|
class MediaData {
|
|
public:
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaData)
|
|
|
|
enum Type {
|
|
AUDIO_DATA = 0,
|
|
VIDEO_DATA
|
|
};
|
|
|
|
MediaData(Type aType,
|
|
int64_t aOffset,
|
|
int64_t aTimestamp,
|
|
int64_t aDuration)
|
|
: mType(aType)
|
|
, mOffset(aOffset)
|
|
, mTime(aTimestamp)
|
|
, mDuration(aDuration)
|
|
, mDiscontinuity(false)
|
|
{}
|
|
|
|
// Type of contained data.
|
|
const Type mType;
|
|
|
|
// Approximate byte offset where this data was demuxed from its media.
|
|
const int64_t mOffset;
|
|
|
|
// Start time of sample, in microseconds.
|
|
const int64_t mTime;
|
|
|
|
// Duration of sample, in microseconds.
|
|
const int64_t mDuration;
|
|
|
|
// True if this is the first sample after a gap or discontinuity in
|
|
// the stream. This is true for the first sample in a stream after a seek.
|
|
bool mDiscontinuity;
|
|
|
|
int64_t GetEndTime() const { return mTime + mDuration; }
|
|
|
|
protected:
|
|
virtual ~MediaData() {}
|
|
|
|
};
|
|
|
|
// Holds chunk a decoded audio frames.
|
|
class AudioData : public MediaData {
|
|
public:
|
|
|
|
AudioData(int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
uint32_t aFrames,
|
|
AudioDataValue* aData,
|
|
uint32_t aChannels,
|
|
uint32_t aRate)
|
|
: MediaData(AUDIO_DATA, aOffset, aTime, aDuration)
|
|
, mFrames(aFrames)
|
|
, mChannels(aChannels)
|
|
, mRate(aRate)
|
|
, mAudioData(aData) {}
|
|
|
|
// Creates a new VideoData identical to aOther, but with a different
|
|
// specified timestamp and duration. All data from aOther is copied
|
|
// into the new AudioData but the audio data which is transferred.
|
|
// After such call, the original aOther is unusable.
|
|
static already_AddRefed<AudioData>
|
|
TransferAndUpdateTimestampAndDuration(AudioData* aOther,
|
|
int64_t aTimestamp,
|
|
int64_t aDuration);
|
|
|
|
size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
|
|
|
|
// If mAudioBuffer is null, creates it from mAudioData.
|
|
void EnsureAudioBuffer();
|
|
|
|
const uint32_t mFrames;
|
|
const uint32_t mChannels;
|
|
const uint32_t mRate;
|
|
// At least one of mAudioBuffer/mAudioData must be non-null.
|
|
// mChannels channels, each with mFrames frames
|
|
nsRefPtr<SharedBuffer> mAudioBuffer;
|
|
// mFrames frames, each with mChannels values
|
|
nsAutoArrayPtr<AudioDataValue> mAudioData;
|
|
|
|
protected:
|
|
~AudioData() {}
|
|
};
|
|
|
|
namespace layers {
|
|
class TextureClient;
|
|
class PlanarYCbCrImage;
|
|
}
|
|
|
|
class VideoInfo;
|
|
|
|
// Holds a decoded video frame, in YCbCr format. These are queued in the reader.
|
|
class VideoData : public MediaData {
|
|
public:
|
|
typedef gfx::IntRect IntRect;
|
|
typedef gfx::IntSize IntSize;
|
|
typedef layers::ImageContainer ImageContainer;
|
|
typedef layers::Image Image;
|
|
typedef layers::PlanarYCbCrImage PlanarYCbCrImage;
|
|
|
|
// YCbCr data obtained from decoding the video. The index's are:
|
|
// 0 = Y
|
|
// 1 = Cb
|
|
// 2 = Cr
|
|
struct YCbCrBuffer {
|
|
struct Plane {
|
|
uint8_t* mData;
|
|
uint32_t mWidth;
|
|
uint32_t mHeight;
|
|
uint32_t mStride;
|
|
uint32_t mOffset;
|
|
uint32_t mSkip;
|
|
};
|
|
|
|
Plane mPlanes[3];
|
|
};
|
|
|
|
// Constructs a VideoData object. If aImage is nullptr, creates a new Image
|
|
// holding a copy of the YCbCr data passed in aBuffer. If aImage is not
|
|
// nullptr, it's stored as the underlying video image and aBuffer is assumed
|
|
// to point to memory within aImage so no copy is made. aTimecode is a codec
|
|
// specific number representing the timestamp of the frame of video data.
|
|
// Returns nsnull if an error occurs. This may indicate that memory couldn't
|
|
// be allocated to create the VideoData object, or it may indicate some
|
|
// problem with the input data (e.g. negative stride).
|
|
static already_AddRefed<VideoData> Create(VideoInfo& aInfo,
|
|
ImageContainer* aContainer,
|
|
Image* aImage,
|
|
int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
const YCbCrBuffer &aBuffer,
|
|
bool aKeyframe,
|
|
int64_t aTimecode,
|
|
const IntRect& aPicture);
|
|
|
|
// Variant that always makes a copy of aBuffer
|
|
static already_AddRefed<VideoData> Create(VideoInfo& aInfo,
|
|
ImageContainer* aContainer,
|
|
int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
const YCbCrBuffer &aBuffer,
|
|
bool aKeyframe,
|
|
int64_t aTimecode,
|
|
const IntRect& aPicture);
|
|
|
|
// Variant to create a VideoData instance given an existing aImage
|
|
static already_AddRefed<VideoData> Create(VideoInfo& aInfo,
|
|
Image* aImage,
|
|
int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
const YCbCrBuffer &aBuffer,
|
|
bool aKeyframe,
|
|
int64_t aTimecode,
|
|
const IntRect& aPicture);
|
|
|
|
static already_AddRefed<VideoData> Create(VideoInfo& aInfo,
|
|
ImageContainer* aContainer,
|
|
int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
layers::TextureClient* aBuffer,
|
|
bool aKeyframe,
|
|
int64_t aTimecode,
|
|
const IntRect& aPicture);
|
|
|
|
static already_AddRefed<VideoData> CreateFromImage(VideoInfo& aInfo,
|
|
ImageContainer* aContainer,
|
|
int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
const nsRefPtr<Image>& aImage,
|
|
bool aKeyframe,
|
|
int64_t aTimecode,
|
|
const IntRect& aPicture);
|
|
|
|
// Creates a new VideoData identical to aOther, but with a different
|
|
// specified duration. All data from aOther is copied into the new
|
|
// VideoData. The new VideoData's mImage field holds a reference to
|
|
// aOther's mImage, i.e. the Image is not copied. This function is useful
|
|
// in reader backends that can't determine the duration of a VideoData
|
|
// until the next frame is decoded, i.e. it's a way to change the const
|
|
// duration field on a VideoData.
|
|
static already_AddRefed<VideoData> ShallowCopyUpdateDuration(VideoData* aOther,
|
|
int64_t aDuration);
|
|
|
|
// Creates a new VideoData identical to aOther, but with a different
|
|
// specified timestamp. All data from aOther is copied into the new
|
|
// VideoData, as ShallowCopyUpdateDuration() does.
|
|
static already_AddRefed<VideoData> ShallowCopyUpdateTimestamp(VideoData* aOther,
|
|
int64_t aTimestamp);
|
|
|
|
// Creates a new VideoData identical to aOther, but with a different
|
|
// specified timestamp and duration. All data from aOther is copied
|
|
// into the new VideoData, as ShallowCopyUpdateDuration() does.
|
|
static already_AddRefed<VideoData>
|
|
ShallowCopyUpdateTimestampAndDuration(VideoData* aOther, int64_t aTimestamp,
|
|
int64_t aDuration);
|
|
|
|
// Initialize PlanarYCbCrImage. Only When aCopyData is true,
|
|
// video data is copied to PlanarYCbCrImage.
|
|
static void SetVideoDataToImage(PlanarYCbCrImage* aVideoImage,
|
|
VideoInfo& aInfo,
|
|
const YCbCrBuffer &aBuffer,
|
|
const IntRect& aPicture,
|
|
bool aCopyData);
|
|
|
|
// Constructs a duplicate VideoData object. This intrinsically tells the
|
|
// player that it does not need to update the displayed frame when this
|
|
// frame is played; this frame is identical to the previous.
|
|
static already_AddRefed<VideoData> CreateDuplicate(int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
int64_t aTimecode)
|
|
{
|
|
nsRefPtr<VideoData> rv = new VideoData(aOffset, aTime, aDuration, aTimecode);
|
|
return rv.forget();
|
|
}
|
|
|
|
size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const;
|
|
|
|
// Dimensions at which to display the video frame. The picture region
|
|
// will be scaled to this size. This is should be the picture region's
|
|
// dimensions scaled with respect to its aspect ratio.
|
|
const IntSize mDisplay;
|
|
|
|
// Codec specific internal time code. For Ogg based codecs this is the
|
|
// granulepos.
|
|
const int64_t mTimecode;
|
|
|
|
// This frame's image.
|
|
nsRefPtr<Image> mImage;
|
|
|
|
// When true, denotes that this frame is identical to the frame that
|
|
// came before; it's a duplicate. mBuffer will be empty.
|
|
const bool mDuplicate;
|
|
const bool mKeyframe;
|
|
|
|
VideoData(int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
int64_t aTimecode);
|
|
|
|
VideoData(int64_t aOffset,
|
|
int64_t aTime,
|
|
int64_t aDuration,
|
|
bool aKeyframe,
|
|
int64_t aTimecode,
|
|
IntSize aDisplay);
|
|
|
|
protected:
|
|
~VideoData();
|
|
};
|
|
|
|
// LargeDataBuffer is a ref counted fallible TArray.
|
|
// It is designed to share potentially big byte arrays.
|
|
class LargeDataBuffer : public FallibleTArray<uint8_t> {
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(LargeDataBuffer);
|
|
|
|
private:
|
|
~LargeDataBuffer() {}
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // MediaData_h
|