Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-28 21:28:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1146222: use nsAutoCString to store mimetype string. r=karlt

Browse Source 
We use a nsAutoCString as the mimetype is typically less than 64 characters
and prevent a heap allocation (and the unecessary fragmentation linked to it)
This commit is contained in:
Jean-Yves Avenard 2015-03-24 14:45:17 +11:00
parent 3a86eefdcd
commit 04753af547
27 changed files with 75 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
dom/media/fmp4/AVCCDecoderModule.cpp
View File

@ -274,8 +274,8 @@ AVCCDecoderModule::CreateVideoDecoder(const mp4_demuxer::VideoDecoderConfig& aCo
{
nsRefPtr<MediaDataDecoder> decoder;
if ((strcmp(aConfig.mime_type, "video/avc") &&
strcmp(aConfig.mime_type, "video/mp4")) ||
if ((!aConfig.mime_type.EqualsLiteral("video/avc") &&
!aConfig.mime_type.EqualsLiteral("video/mp4")) ||
!mPDM->DecoderNeedsAVCC(aConfig)) {
// There is no need for an AVCC wrapper for non-AVC content.
decoder = mPDM->CreateVideoDecoder(aConfig,
@ -305,13 +305,13 @@ AVCCDecoderModule::CreateAudioDecoder(const mp4_demuxer::AudioDecoderConfig& aCo
}
bool
AVCCDecoderModule::SupportsAudioMimeType(const char* aMimeType)
AVCCDecoderModule::SupportsAudioMimeType(const nsACString& aMimeType)
{
return mPDM->SupportsAudioMimeType(aMimeType);
}
bool
AVCCDecoderModule::SupportsVideoMimeType(const char* aMimeType)
AVCCDecoderModule::SupportsVideoMimeType(const nsACString& aMimeType)
{
return mPDM->SupportsVideoMimeType(aMimeType);
}

4
dom/media/fmp4/AVCCDecoderModule.h
View File

@ -41,8 +41,8 @@ public:
FlushableMediaTaskQueue* aAudioTaskQueue,
MediaDataDecoderCallback* aCallback) override;
virtual bool SupportsAudioMimeType(const char* aMimeType) override;
virtual bool SupportsVideoMimeType(const char* aMimeType) override;
virtual bool SupportsAudioMimeType(const nsACString& aMimeType) override;
virtual bool SupportsVideoMimeType(const nsACString& aMimeType) override;
private:
nsRefPtr<PlatformDecoderModule> mPDM;

2
dom/media/fmp4/BlankDecoderModule.cpp
View File

@ -238,7 +238,7 @@ public:
}
virtual bool
SupportsAudioMimeType(const char* aMimeType) override
SupportsAudioMimeType(const nsACString& aMimeType) override
{
return true;
}

14
dom/media/fmp4/MP4Reader.cpp
View File

@ -311,19 +311,19 @@ MP4Reader::ExtractCryptoInitData(nsTArray<uint8_t>& aInitData)
}
bool
MP4Reader::IsSupportedAudioMimeType(const char* aMimeType)
MP4Reader::IsSupportedAudioMimeType(const nsACString& aMimeType)
{
return (!strcmp(aMimeType, "audio/mpeg") ||
!strcmp(aMimeType, "audio/mp4a-latm")) &&
return (aMimeType.EqualsLiteral("audio/mpeg") ||
aMimeType.EqualsLiteral("audio/mp4a-latm")) &&
mPlatform->SupportsAudioMimeType(aMimeType);
}
bool
MP4Reader::IsSupportedVideoMimeType(const char* aMimeType)
MP4Reader::IsSupportedVideoMimeType(const nsACString& aMimeType)
{
return (!strcmp(aMimeType, "video/mp4") ||
!strcmp(aMimeType, "video/avc") ||
!strcmp(aMimeType, "video/x-vnd.on2.vp6")) &&
return (aMimeType.EqualsLiteral("video/mp4") ||
aMimeType.EqualsLiteral("video/avc") ||
aMimeType.EqualsLiteral("video/x-vnd.on2.vp6")) &&
mPlatform->SupportsVideoMimeType(aMimeType);
}

4
dom/media/fmp4/MP4Reader.h
View File

@ -133,8 +133,8 @@ private:
void Flush(mp4_demuxer::TrackType aTrack);
void DrainComplete(mp4_demuxer::TrackType aTrack);
void UpdateIndex();
bool IsSupportedAudioMimeType(const char* aMimeType);
bool IsSupportedVideoMimeType(const char* aMimeType);
bool IsSupportedAudioMimeType(const nsACString& aMimeType);
bool IsSupportedVideoMimeType(const nsACString& aMimeType);
void NotifyResourcesStatusChanged();
void RequestCodecResource();
virtual bool IsWaitingOnCDMResource() override;

8
dom/media/fmp4/PlatformDecoderModule.cpp
View File

@ -180,15 +180,15 @@ PlatformDecoderModule::CreatePDM()
}
bool
PlatformDecoderModule::SupportsAudioMimeType(const char* aMimeType)
PlatformDecoderModule::SupportsAudioMimeType(const nsACString& aMimeType)
{
return !strcmp(aMimeType, "audio/mp4a-latm");
return aMimeType.EqualsLiteral("audio/mp4a-latm");
}
bool
PlatformDecoderModule::SupportsVideoMimeType(const char* aMimeType)
PlatformDecoderModule::SupportsVideoMimeType(const nsACString& aMimeType)
{
return !strcmp(aMimeType, "video/mp4") || !strcmp(aMimeType, "video/avc");
return aMimeType.EqualsLiteral("video/mp4") || aMimeType.EqualsLiteral("video/avc");
}
bool

4
dom/media/fmp4/PlatformDecoderModule.h
View File

@ -122,8 +122,8 @@ public:
// An audio decoder module must support AAC by default.
// If more audio codec is to be supported, SupportsAudioMimeType will have
// to be extended
virtual bool SupportsAudioMimeType(const char* aMimeType);
virtual bool SupportsVideoMimeType(const char* aMimeType);
virtual bool SupportsAudioMimeType(const nsACString& aMimeType);
virtual bool SupportsVideoMimeType(const nsACString& aMimeType);
// Indicates if the video decoder requires AVCC format.
virtual bool DecoderNeedsAVCC(const mp4_demuxer::VideoDecoderConfig& aConfig);

15
dom/media/fmp4/android/AndroidDecoderModule.cpp
View File

@ -18,6 +18,7 @@
#include "nsThreadUtils.h"
#include "nsAutoPtr.h"
#include "nsPromiseFlatString.h"
#include <jni.h>
#include <string.h>
@ -28,14 +29,10 @@ using namespace mozilla::widget::sdk;
namespace mozilla {
static MediaCodec::LocalRef CreateDecoder(const char* aMimeType)
static MediaCodec::LocalRef CreateDecoder(const nsACString& aMimeType)
{
if (!aMimeType) {
return nullptr;
}
MediaCodec::LocalRef codec;
NS_ENSURE_SUCCESS(MediaCodec::CreateDecoderByType(aMimeType, &codec), nullptr);
NS_ENSURE_SUCCESS(MediaCodec::CreateDecoderByType(PromiseFlatCString(aMimeType).get(), &codec), nullptr);
return codec;
}
@ -251,7 +248,7 @@ public:
};
bool AndroidDecoderModule::SupportsAudioMimeType(const char* aMimeType) {
bool AndroidDecoderModule::SupportsAudioMimeType(const nsACString& aMimeType) {
return static_cast<bool>(CreateDecoder(aMimeType));
}
@ -300,11 +297,11 @@ AndroidDecoderModule::CreateAudioDecoder(const mp4_demuxer::AudioDecoderConfig&
}
MediaCodecDataDecoder::MediaCodecDataDecoder(MediaData::Type aType,
const char* aMimeType,
const nsACString& aMimeType,
MediaFormat::Param aFormat,
MediaDataDecoderCallback* aCallback)
: mType(aType)
, mMimeType(strdup(aMimeType))
, mMimeType(aMimeType)
, mFormat(aFormat)
, mCallback(aCallback)
, mInputBuffers(nullptr)

6
dom/media/fmp4/android/AndroidDecoderModule.h
View File

@ -35,14 +35,14 @@ public:
AndroidDecoderModule() {}
virtual ~AndroidDecoderModule() {}
virtual bool SupportsAudioMimeType(const char* aMimeType) override;
virtual bool SupportsAudioMimeType(const nsACString& aMimeType) override;
};
class MediaCodecDataDecoder : public MediaDataDecoder {
public:
MediaCodecDataDecoder(MediaData::Type aType,
const char* aMimeType,
const nsACString& aMimeType,
widget::sdk::MediaFormat::Param aFormat,
MediaDataDecoderCallback* aCallback);
@ -59,7 +59,7 @@ protected:
MediaData::Type mType;
nsAutoPtr<char> mMimeType;
nsAutoCString mMimeType;
widget::sdk::MediaFormat::GlobalRef mFormat;
MediaDataDecoderCallback* mCallback;

6
dom/media/fmp4/apple/AppleATDecoder.cpp
View File

@ -35,14 +35,14 @@ AppleATDecoder::AppleATDecoder(const mp4_demuxer::AudioDecoderConfig& aConfig,
MOZ_COUNT_CTOR(AppleATDecoder);
LOG("Creating Apple AudioToolbox decoder");
LOG("Audio Decoder configuration: %s %d Hz %d channels %d bits per channel",
mConfig.mime_type,
mConfig.mime_type.get(),
mConfig.samples_per_second,
mConfig.channel_count,
mConfig.bits_per_sample);
if (!strcmp(mConfig.mime_type, "audio/mpeg")) {
if (mConfig.mime_type.EqualsLiteral("audio/mpeg")) {
mFormatID = kAudioFormatMPEGLayer3;
} else if (!strcmp(mConfig.mime_type, "audio/mp4a-latm")) {
} else if (mConfig.mime_type.EqualsLiteral("audio/mp4a-latm")) {
mFormatID = kAudioFormatMPEG4AAC;
} else {
mFormatID = 0;

4
dom/media/fmp4/apple/AppleDecoderModule.cpp
View File

@ -192,9 +192,9 @@ AppleDecoderModule::CreateAudioDecoder(const mp4_demuxer::AudioDecoderConfig& aC
}
bool
AppleDecoderModule::SupportsAudioMimeType(const char* aMimeType)
AppleDecoderModule::SupportsAudioMimeType(const nsACString& aMimeType)
{
return !strcmp(aMimeType, "audio/mp4a-latm") || !strcmp(aMimeType, "audio/mpeg");
return aMimeType.EqualsLiteral("audio/mp4a-latm") || aMimeType.EqualsLiteral("audio/mpeg");
}
bool

2
dom/media/fmp4/apple/AppleDecoderModule.h
View File

@ -32,7 +32,7 @@ public:
FlushableMediaTaskQueue* aAudioTaskQueue,
MediaDataDecoderCallback* aCallback) override;
virtual bool SupportsAudioMimeType(const char* aMimeType) override;
virtual bool SupportsAudioMimeType(const nsACString& aMimeType) override;
virtual bool
DecoderNeedsAVCC(const mp4_demuxer::VideoDecoderConfig& aConfig) override;

6
dom/media/fmp4/ffmpeg/FFmpegAudioDecoder.cpp
View File

@ -170,13 +170,13 @@ FFmpegAudioDecoder<LIBAV_VER>::Drain()
}
AVCodecID
FFmpegAudioDecoder<LIBAV_VER>::GetCodecId(const char* aMimeType)
FFmpegAudioDecoder<LIBAV_VER>::GetCodecId(const nsACString& aMimeType)
{
if (!strcmp(aMimeType, "audio/mpeg")) {
if (aMimeType.EqualsLiteral("audio/mpeg")) {
return AV_CODEC_ID_MP3;
}
if (!strcmp(aMimeType, "audio/mp4a-latm")) {
if (aMimeType.EqualsLiteral("audio/mp4a-latm")) {
return AV_CODEC_ID_AAC;
}

3
dom/media/fmp4/ffmpeg/FFmpegAudioDecoder.h
View File

@ -8,7 +8,6 @@
#define __FFmpegAACDecoder_h__
#include "FFmpegDataDecoder.h"
#include "mp4_demuxer/DecoderData.h"
namespace mozilla
{
@ -29,7 +28,7 @@ public:
virtual nsresult Init() override;
virtual nsresult Input(mp4_demuxer::MP4Sample* aSample) override;
virtual nsresult Drain() override;
static AVCodecID GetCodecId(const char* aMimeType);
static AVCodecID GetCodecId(const nsACString& aMimeType);
private:
void DecodePacket(mp4_demuxer::MP4Sample* aSample);

4
dom/media/fmp4/ffmpeg/FFmpegDecoderModule.h
View File

@ -51,12 +51,12 @@ public:
return decoder.forget();
}
virtual bool SupportsAudioMimeType(const char* aMimeType) override
virtual bool SupportsAudioMimeType(const nsACString& aMimeType) override
{
return FFmpegAudioDecoder<V>::GetCodecId(aMimeType) != AV_CODEC_ID_NONE;
}
virtual bool SupportsVideoMimeType(const char* aMimeType) override
virtual bool SupportsVideoMimeType(const nsACString& aMimeType) override
{
return FFmpegH264Decoder<V>::GetCodecId(aMimeType) != AV_CODEC_ID_NONE;
}

6
dom/media/fmp4/ffmpeg/FFmpegH264Decoder.cpp
View File

@ -287,13 +287,13 @@ FFmpegH264Decoder<LIBAV_VER>::~FFmpegH264Decoder()
}
AVCodecID
FFmpegH264Decoder<LIBAV_VER>::GetCodecId(const char* aMimeType)
FFmpegH264Decoder<LIBAV_VER>::GetCodecId(const nsACString& aMimeType)
{
if (!strcmp(aMimeType, "video/avc") || !strcmp(aMimeType, "video/mp4")) {
if (aMimeType.EqualsLiteral("video/avc") || aMimeType.EqualsLiteral("video/mp4")) {
return AV_CODEC_ID_H264;
}
if (!strcmp(aMimeType, "video/x-vnd.on2.vp6")) {
if (aMimeType.EqualsLiteral("video/x-vnd.on2.vp6")) {
return AV_CODEC_ID_VP6F;
}

2
dom/media/fmp4/ffmpeg/FFmpegH264Decoder.h
View File

@ -40,7 +40,7 @@ public:
virtual nsresult Input(mp4_demuxer::MP4Sample* aSample) override;
virtual nsresult Drain() override;
virtual nsresult Flush() override;
static AVCodecID GetCodecId(const char* aMimeType);
static AVCodecID GetCodecId(const nsACString& aMimeType);
private:
void DecodeFrame(mp4_demuxer::MP4Sample* aSample);

4
dom/media/fmp4/gmp/GMPDecoderModule.cpp
View File

@ -46,7 +46,7 @@ GMPDecoderModule::CreateVideoDecoder(const mp4_demuxer::VideoDecoderConfig& aCon
FlushableMediaTaskQueue* aVideoTaskQueue,
MediaDataDecoderCallback* aCallback)
{
if (strcmp(aConfig.mime_type, "video/avc") != 0) {
if (!aConfig.mime_type.EqualsLiteral("video/avc")) {
return nullptr;
}
@ -64,7 +64,7 @@ GMPDecoderModule::CreateAudioDecoder(const mp4_demuxer::AudioDecoderConfig& aCon
FlushableMediaTaskQueue* aAudioTaskQueue,
MediaDataDecoderCallback* aCallback)
{
if (strcmp(aConfig.mime_type, "audio/mp4a-latm") != 0) {
if (!aConfig.mime_type.EqualsLiteral("audio/mp4a-latm")) {
return nullptr;
}

2
dom/media/fmp4/gonk/GonkAudioDecoderManager.cpp
View File

@ -51,7 +51,7 @@ GonkAudioDecoderManager::GonkAudioDecoderManager(
mUserData.AppendElements(aConfig.audio_specific_config->Elements(),
aConfig.audio_specific_config->Length());
// Pass through mp3 without applying an ADTS header.
if (strcmp(aConfig.mime_type, "audio/mp4a-latm") != 0) {
if (!aConfig.mime_type.EqualsLiteral("audio/mp4a-latm")) {
mUseAdts = false;
}
}

4
dom/media/fmp4/wmf/WMFAudioMFTManager.cpp
View File

@ -77,9 +77,9 @@ WMFAudioMFTManager::WMFAudioMFTManager(
{
MOZ_COUNT_CTOR(WMFAudioMFTManager);
if (!strcmp(aConfig.mime_type, "audio/mpeg")) {
if (aConfig.mime_type.EqualsLiteral("audio/mpeg")) {
mStreamType = MP3;
} else if (!strcmp(aConfig.mime_type, "audio/mp4a-latm")) {
} else if (aConfig.mime_type.EqualsLiteral("audio/mp4a-latm")) {
mStreamType = AAC;
AACAudioSpecificConfigToUserData(aConfig.aac_profile,
aConfig.audio_specific_config->Elements(),

16
dom/media/fmp4/wmf/WMFDecoderModule.cpp
View File

@ -118,19 +118,19 @@ WMFDecoderModule::SupportsSharedDecoders(const mp4_demuxer::VideoDecoderConfig&
}
bool
WMFDecoderModule::SupportsVideoMimeType(const char* aMimeType)
WMFDecoderModule::SupportsVideoMimeType(const nsACString& aMimeType)
{
return !strcmp(aMimeType, "video/mp4") ||
!strcmp(aMimeType, "video/avc") ||
!strcmp(aMimeType, "video/webm; codecs=vp8") ||
!strcmp(aMimeType, "video/webm; codecs=vp9");
return aMimeType.EqualsLiteral("video/mp4") ||
aMimeType.EqualsLiteral("video/avc") ||
aMimeType.EqualsLiteral("video/webm; codecs=vp8") ||
aMimeType.EqualsLiteral("video/webm; codecs=vp9");
}
bool
WMFDecoderModule::SupportsAudioMimeType(const char* aMimeType)
WMFDecoderModule::SupportsAudioMimeType(const nsACString& aMimeType)
{
return !strcmp(aMimeType, "audio/mp4a-latm") ||
!strcmp(aMimeType, "audio/mpeg");
return aMimeType.EqualsLiteral("audio/mp4a-latm") ||
aMimeType.EqualsLiteral("audio/mpeg");
}
static bool

4
dom/media/fmp4/wmf/WMFDecoderModule.h
View File

@ -31,8 +31,8 @@ public:
FlushableMediaTaskQueue* aAudioTaskQueue,
MediaDataDecoderCallback* aCallback) override;
bool SupportsVideoMimeType(const char* aMimeType) override;
bool SupportsAudioMimeType(const char* aMimeType) override;
bool SupportsVideoMimeType(const nsACString& aMimeType) override;
bool SupportsAudioMimeType(const nsACString& aMimeType) override;
virtual void DisableHardwareAcceleration() override
{

8
dom/media/fmp4/wmf/WMFVideoMFTManager.cpp
View File

@ -84,12 +84,12 @@ WMFVideoMFTManager::WMFVideoMFTManager(
MOZ_COUNT_CTOR(WMFVideoMFTManager);
// Need additional checks/params to check vp8/vp9
if (!strcmp(aConfig.mime_type, "video/mp4") ||
!strcmp(aConfig.mime_type, "video/avc")) {
if (aConfig.mime_type.EqualsLiteral("video/mp4") ||
aConfig.mime_type.EqualsLiteral("video/avc")) {
mStreamType = H264;
} else if (!strcmp(aConfig.mime_type, "video/webm; codecs=vp8")) {
} else if (aConfig.mime_type.EqualsLiteral("video/webm; codecs=vp8")) {
mStreamType = VP8;
} else if (!strcmp(aConfig.mime_type, "video/webm; codecs=vp9")) {
} else if (aConfig.mime_type.EqualsLiteral("video/webm; codecs=vp9")) {
mStreamType = VP9;
} else {
mStreamType = Unknown;

6
dom/media/webm/IntelWebMVideoDecoder.cpp
View File

@ -112,10 +112,10 @@ IntelWebMVideoDecoder::Create(WebMReader* aReader)
}
bool
IntelWebMVideoDecoder::IsSupportedVideoMimeType(const char* aMimeType)
IntelWebMVideoDecoder::IsSupportedVideoMimeType(const nsACString& aMimeType)
{
return (!strcmp(aMimeType, "video/webm; codecs=vp8") ||
!strcmp(aMimeType, "video/webm; codecs=vp9")) &&
return (aMimeType.EqualsLiteral("video/webm; codecs=vp8") ||
aMimeType.EqualsLiteral("video/webm; codecs=vp9")) &&
mPlatform->SupportsVideoMimeType(aMimeType);
}

2
dom/media/webm/IntelWebMVideoDecoder.h
View File

@ -54,7 +54,7 @@ private:
bool SkipVideoDemuxToNextKeyFrame(int64_t aTimeThreshold, uint32_t& parsed);
bool IsSupportedVideoMimeType(const char* aMimeType);
bool IsSupportedVideoMimeType(const nsACString& aMimeType);
VP8Sample* PopSample();

3
media/libstagefright/binding/DecoderData.cpp
View File

@ -134,7 +134,6 @@ CryptoSample::Update(sp<MetaData>& aMetaData)
void
TrackConfig::Update(sp<MetaData>& aMetaData, const char* aMimeType)
{
// aMimeType points to a string from MediaDefs.cpp so we don't need to copy it
mime_type = aMimeType;
duration = FindInt64(aMetaData, kKeyDuration);
media_time = FindInt64(aMetaData, kKeyMediaTime);
@ -176,7 +175,7 @@ bool
AudioDecoderConfig::IsValid()
{
return channel_count > 0 && samples_per_second > 0 && frequency_index > 0 &&
(mime_type != MEDIA_MIMETYPE_AUDIO_AAC || aac_profile > 0);
(!mime_type.Equals(MEDIA_MIMETYPE_AUDIO_AAC) || aac_profile > 0);
}
void

7
media/libstagefright/binding/include/mp4_demuxer/DecoderData.h
View File

@ -7,9 +7,10 @@
#include "mozilla/Types.h"
#include "mozilla/Vector.h"
#include "nsTArray.h"
#include "nsAutoPtr.h"
#include "nsRefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
namespace stagefright
{
@ -87,8 +88,8 @@ public:
class TrackConfig
{
public:
TrackConfig() : mime_type(nullptr), mTrackId(0), duration(0), media_time(0) {}
const char* mime_type;
TrackConfig() : mTrackId(0), duration(0), media_time(0) {}
nsAutoCString mime_type;
uint32_t mTrackId;
int64_t duration;
int64_t media_time;