static nsresult
NegotiatedDetailsToVideoCodecConfigs(const JsepTrackNegotiatedDetails& aDetails,
PtrVector<VideoCodecConfig>* aConfigs)
{
std::vector<JsepCodecDescription*> codecs(GetCodecs(aDetails));
for (const JsepCodecDescription* codec : codecs) {
VideoCodecConfig* config;
if (NS_FAILED(JsepCodecDescToCodecConfig(*codec, &config))) {
return NS_ERROR_INVALID_ARG;
}
for (size_t i = 0; i < aDetails.GetEncodingCount(); ++i) {
const JsepTrackEncoding& jsepEncoding(aDetails.GetEncoding(i));
if (jsepEncoding.HasFormat(codec->mDefaultPt)) {
VideoCodecConfig::SimulcastEncoding encoding;
encoding.rid = jsepEncoding.mRid;
encoding.constraints = jsepEncoding.mConstraints;
config->mSimulcastEncodings.push_back(encoding);
}
}
aConfigs->values.push_back(config);
}
return NS_OK;
}
void MediaPlayer::load(const String& url, const ContentType& contentType)
{
String type = contentType.type().lower();
String typeCodecs = contentType.parameter(codecs());
// If the MIME type is missing or is not meaningful, try to figure it out from the URL.
if (type.isEmpty() || type == applicationOctetStream() || type == textPlain()) {
if (protocolIs(url, "data"))
type = mimeTypeFromDataURL(url);
else {
size_t pos = url.reverseFind('.');
if (pos != notFound) {
String extension = url.substring(pos + 1);
String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
if (!mediaType.isEmpty())
type = mediaType;
}
}
}
m_url = url;
m_contentMIMEType = type;
m_contentTypeCodecs = typeCodecs;
loadWithNextMediaEngine(0);
}
bool MediaPlayer::load(const URL& url, const ContentType& contentType, const String& keySystem)
{
m_contentMIMEType = contentType.type().lower();
m_contentTypeCodecs = contentType.parameter(codecs());
m_url = url;
m_keySystem = keySystem.lower();
m_contentMIMETypeWasInferredFromExtension = false;
#if ENABLE(MEDIA_SOURCE)
m_mediaSource = 0;
#endif
// If the MIME type is missing or is not meaningful, try to figure it out from the URL.
if (m_contentMIMEType.isEmpty() || m_contentMIMEType == applicationOctetStream() || m_contentMIMEType == textPlain()) {
if (m_url.protocolIsData())
m_contentMIMEType = mimeTypeFromDataURL(m_url.string());
else {
String lastPathComponent = url.lastPathComponent();
size_t pos = lastPathComponent.reverseFind('.');
if (pos != notFound) {
String extension = lastPathComponent.substring(pos + 1);
String mediaType = MIMETypeRegistry::getMediaMIMETypeForExtension(extension);
if (!mediaType.isEmpty()) {
m_contentMIMEType = mediaType;
m_contentMIMETypeWasInferredFromExtension = true;
}
}
}
}
loadWithNextMediaEngine(0);
return m_currentMediaEngine;
}
void closeLibInstance()
{
if (lib)
{
codecs().removeImageCodec(lib);
}
delete lib;
lib = nullptr;
}
bool MediaPlayer::load(const URL& url, const ContentType& contentType, MediaSourcePrivateClient* mediaSource)
{
ASSERT(mediaSource);
m_mediaSource = mediaSource;
m_contentMIMEType = contentType.type().lower();
m_contentTypeCodecs = contentType.parameter(codecs());
m_url = url;
m_keySystem = "";
m_contentMIMETypeWasInferredFromExtension = false;
loadWithNextMediaEngine(0);
return m_currentMediaEngine;
}
Library* getLibInstance(Engine* engine)
{
if (lib == nullptr)
{
lib = new PluginImageCodecJPEG(*engine);
if (lib)
{
codecs().addImageCodec(lib);
}
}
return lib;
}
bool MediaPlayer::load(const URL& url, const ContentType& contentType, MediaSourcePrivateClient* mediaSource)
{
ASSERT(!m_reloadTimer.isActive());
ASSERT(mediaSource);
m_mediaSource = mediaSource;
m_contentMIMEType = contentType.type().convertToASCIILowercase();
m_contentTypeCodecs = contentType.parameter(codecs());
m_url = url;
m_keySystem = emptyString();
m_contentMIMETypeWasInferredFromExtension = false;
loadWithNextMediaEngine(0);
return m_currentMediaEngine;
}
static nsresult
NegotiatedDetailsToAudioCodecConfigs(const JsepTrackNegotiatedDetails& aDetails,
PtrVector<AudioCodecConfig>* aConfigs)
{
std::vector<JsepCodecDescription*> codecs(GetCodecs(aDetails));
for (const JsepCodecDescription* codec : codecs) {
AudioCodecConfig* config;
if (NS_FAILED(JsepCodecDescToCodecConfig(*codec, &config))) {
return NS_ERROR_INVALID_ARG;
}
aConfigs->values.push_back(config);
}
return NS_OK;
}
MediaPlayer::SupportsType MediaPlayer::supportsType(const ContentType& contentType)
{
String type = contentType.type().lower();
String typeCodecs = contentType.parameter(codecs());
// 4.8.10.3 MIME types - The canPlayType(type) method must return the empty string if type is a type that the
// user agent knows it cannot render or is the type "application/octet-stream"
if (type == applicationOctetStream())
return IsNotSupported;
MediaPlayerFactory* engine = bestMediaEngineForTypeAndCodecs(type, typeCodecs);
if (!engine)
return IsNotSupported;
return engine->supportsTypeAndCodecs(type, typeCodecs);
}
void SDPTest::testReinvite()
{
std::cout << "------------ SDPTest::testReinvite --------------------" << std::endl;
CPPUNIT_ASSERT(session_->getPublishedIP().empty());
CPPUNIT_ASSERT(session_->getRemoteIP().empty());
std::vector<int> codecSelection;
codecSelection.push_back(PAYLOAD_CODEC_ULAW);
codecSelection.push_back(PAYLOAD_CODEC_ALAW);
codecSelection.push_back(PAYLOAD_CODEC_G722);
session_->setPublishedIP(LOCALHOST);
session_->setLocalPublishedAudioPort(49567);
std::vector<std::map<std::string, std::string> > videoCodecs(createVideoCodecs());
session_->createOffer(codecSelection, videoCodecs);
pjmedia_sdp_session *remoteAnswer;
// pjmedia_sdp_parse(session_->memPool_.get(), test[0].offer_answer[0].sdp2, strlen(test[0].offer_answer[0].sdp2), &remoteAnswer);
pjmedia_sdp_parse(session_->memPool_.get(), (char*) sdp_answer1, strlen(sdp_answer1), &remoteAnswer);
receiveAnswerAfterInitialOffer(remoteAnswer);
session_->startNegotiation();
session_->setMediaTransportInfoFromRemoteSdp();
CPPUNIT_ASSERT(session_->getPublishedIP() == LOCALHOST);
CPPUNIT_ASSERT(session_->getRemoteIP() == "host.example.com");
std::vector<ring::AudioCodec*> codecs(session_->getSessionAudioMedia());
ring::AudioCodec *codec = codecs[0];
CPPUNIT_ASSERT(codec and codec->getMimeSubtype() == "PCMU");
pjmedia_sdp_session *reinviteOffer;
pjmedia_sdp_parse(session_->memPool_.get(), (char*) sdp_reinvite, strlen(sdp_reinvite), &reinviteOffer);
session_->receiveOffer(reinviteOffer, codecSelection, videoCodecs);
session_->startNegotiation();
session_->setMediaTransportInfoFromRemoteSdp();
CPPUNIT_ASSERT(session_->getRemoteIP() == "host.exampleReinvite.com");
}
// -----------------------------------------------------------------------------
// CMceComAudioStream::UpdateDefaultCodecL
// -----------------------------------------------------------------------------
//
void CMceComAudioStream::UpdateDefaultCodecL()
{
CMceComCodec* highestPrioritySendCodec = NULL;
CMceComCodec* codec = NULL;
const RPointerArray< CMceComCodec >& allCodecs = reinterpret_cast< const RPointerArray<CMceComCodec>& >( Codecs() );
CMceComCodec::TIterator codecs( allCodecs,
CMceComCodec::TIterator::EFilterIsNegotiated );
MCE_ITERATOR_FIND_NEXT( codecs, highestPrioritySendCodec,
highestPrioritySendCodec->SendSupported() );
// If no negotiated send codecs, disable all.
// If send codec changed, enable new one and disable other send codecs.
if ( !highestPrioritySendCodec ||
( highestPrioritySendCodec &&
!highestPrioritySendCodec->iIsEnabled ) )
{
TBool newDefaultCodecSet( EFalse );
codecs.Reset();
codecs.SetFilter( CMceComCodec::TIterator::EFilterNone );
while( codecs.Next( codec ) )
{
if ( !newDefaultCodecSet && codec->iIsNegotiated && codec->SendSupported() )
{
codec->SetEnabled( ETrue );
newDefaultCodecSet = ETrue;
}
else
{
codec->SetEnabled( EFalse );
}
}
}
}
SkCodec* SkIcoCodec::NewFromStream(SkStream* stream, Result* result) {
// Ensure that we do not leak the input stream
std::unique_ptr<SkStream> inputStream(stream);
// Header size constants
static const uint32_t kIcoDirectoryBytes = 6;
static const uint32_t kIcoDirEntryBytes = 16;
// Read the directory header
std::unique_ptr<uint8_t[]> dirBuffer(new uint8_t[kIcoDirectoryBytes]);
if (inputStream.get()->read(dirBuffer.get(), kIcoDirectoryBytes) !=
kIcoDirectoryBytes) {
SkCodecPrintf("Error: unable to read ico directory header.\n");
*result = kIncompleteInput;
return nullptr;
}
// Process the directory header
const uint16_t numImages = get_short(dirBuffer.get(), 4);
if (0 == numImages) {
SkCodecPrintf("Error: No images embedded in ico.\n");
*result = kInvalidInput;
return nullptr;
}
// This structure is used to represent the vital information about entries
// in the directory header. We will obtain this information for each
// directory entry.
struct Entry {
uint32_t offset;
uint32_t size;
};
SkAutoFree dirEntryBuffer(sk_malloc_flags(sizeof(Entry) * numImages,
SK_MALLOC_TEMP));
if (!dirEntryBuffer) {
SkCodecPrintf("Error: OOM allocating ICO directory for %i images.\n",
numImages);
*result = kInternalError;
return nullptr;
}
auto* directoryEntries = reinterpret_cast<Entry*>(dirEntryBuffer.get());
// Iterate over directory entries
for (uint32_t i = 0; i < numImages; i++) {
uint8_t entryBuffer[kIcoDirEntryBytes];
if (inputStream->read(entryBuffer, kIcoDirEntryBytes) !=
kIcoDirEntryBytes) {
SkCodecPrintf("Error: Dir entries truncated in ico.\n");
*result = kIncompleteInput;
return nullptr;
}
// The directory entry contains information such as width, height,
// bits per pixel, and number of colors in the color palette. We will
// ignore these fields since they are repeated in the header of the
// embedded image. In the event of an inconsistency, we would always
// defer to the value in the embedded header anyway.
// Specifies the size of the embedded image, including the header
uint32_t size = get_int(entryBuffer, 8);
// Specifies the offset of the embedded image from the start of file.
// It does not indicate the start of the pixel data, but rather the
// start of the embedded image header.
uint32_t offset = get_int(entryBuffer, 12);
// Save the vital fields
directoryEntries[i].offset = offset;
directoryEntries[i].size = size;
}
// Default Result, if no valid embedded codecs are found.
*result = kInvalidInput;
// It is "customary" that the embedded images will be stored in order of
// increasing offset. However, the specification does not indicate that
// they must be stored in this order, so we will not trust that this is the
// case. Here we sort the embedded images by increasing offset.
struct EntryLessThan {
bool operator() (Entry a, Entry b) const {
return a.offset < b.offset;
}
};
EntryLessThan lessThan;
SkTQSort(directoryEntries, &directoryEntries[numImages - 1], lessThan);
// Now will construct a candidate codec for each of the embedded images
uint32_t bytesRead = kIcoDirectoryBytes + numImages * kIcoDirEntryBytes;
std::unique_ptr<SkTArray<std::unique_ptr<SkCodec>, true>> codecs(
new (SkTArray<std::unique_ptr<SkCodec>, true>)(numImages));
for (uint32_t i = 0; i < numImages; i++) {
uint32_t offset = directoryEntries[i].offset;
uint32_t size = directoryEntries[i].size;
// Ensure that the offset is valid
if (offset < bytesRead) {
SkCodecPrintf("Warning: invalid ico offset.\n");
continue;
}
// If we cannot skip, assume we have reached the end of the stream and
// stop trying to make codecs
if (inputStream.get()->skip(offset - bytesRead) != offset - bytesRead) {
SkCodecPrintf("Warning: could not skip to ico offset.\n");
break;
}
bytesRead = offset;
// Create a new stream for the embedded codec
SkAutoFree buffer(sk_malloc_flags(size, 0));
if (!buffer) {
SkCodecPrintf("Warning: OOM trying to create embedded stream.\n");
break;
}
if (inputStream->read(buffer.get(), size) != size) {
SkCodecPrintf("Warning: could not create embedded stream.\n");
*result = kIncompleteInput;
break;
}
sk_sp<SkData> data(SkData::MakeFromMalloc(buffer.release(), size));
std::unique_ptr<SkMemoryStream> embeddedStream(new SkMemoryStream(data));
bytesRead += size;
// Check if the embedded codec is bmp or png and create the codec
SkCodec* codec = nullptr;
Result dummyResult;
if (SkPngCodec::IsPng((const char*) data->bytes(), data->size())) {
codec = SkPngCodec::NewFromStream(embeddedStream.release(), &dummyResult);
} else {
codec = SkBmpCodec::NewFromIco(embeddedStream.release(), &dummyResult);
}
// Save a valid codec
if (nullptr != codec) {
codecs->push_back().reset(codec);
}
}
// Recognize if there are no valid codecs
if (0 == codecs->count()) {
SkCodecPrintf("Error: could not find any valid embedded ico codecs.\n");
return nullptr;
}
// Use the largest codec as a "suggestion" for image info
size_t maxSize = 0;
int maxIndex = 0;
for (int i = 0; i < codecs->count(); i++) {
SkImageInfo info = codecs->operator[](i)->getInfo();
size_t size = info.getSafeSize(info.minRowBytes());
if (size > maxSize) {
maxSize = size;
maxIndex = i;
}
}
int width = codecs->operator[](maxIndex)->getInfo().width();
int height = codecs->operator[](maxIndex)->getInfo().height();
SkEncodedInfo info = codecs->operator[](maxIndex)->getEncodedInfo();
SkColorSpace* colorSpace = codecs->operator[](maxIndex)->getInfo().colorSpace();
*result = kSuccess;
// The original stream is no longer needed, because the embedded codecs own their
// own streams.
return new SkIcoCodec(width, height, info, codecs.release(), sk_ref_sp(colorSpace));
}
/*
* Assumes IsIco was called and returned true
* Creates an Ico decoder
* Reads enough of the stream to determine the image format
*/
SkCodec* SkIcoCodec::NewFromStream(SkStream* stream) {
// Ensure that we do not leak the input stream
SkAutoTDelete<SkStream> inputStream(stream);
// Header size constants
static const uint32_t kIcoDirectoryBytes = 6;
static const uint32_t kIcoDirEntryBytes = 16;
// Read the directory header
SkAutoTDeleteArray<uint8_t> dirBuffer(new uint8_t[kIcoDirectoryBytes]);
if (inputStream.get()->read(dirBuffer.get(), kIcoDirectoryBytes) !=
kIcoDirectoryBytes) {
SkCodecPrintf("Error: unable to read ico directory header.\n");
return nullptr;
}
// Process the directory header
const uint16_t numImages = get_short(dirBuffer.get(), 4);
if (0 == numImages) {
SkCodecPrintf("Error: No images embedded in ico.\n");
return nullptr;
}
// Ensure that we can read all of indicated directory entries
SkAutoTDeleteArray<uint8_t> entryBuffer(new uint8_t[numImages * kIcoDirEntryBytes]);
if (inputStream.get()->read(entryBuffer.get(), numImages*kIcoDirEntryBytes) !=
numImages*kIcoDirEntryBytes) {
SkCodecPrintf("Error: unable to read ico directory entries.\n");
return nullptr;
}
// This structure is used to represent the vital information about entries
// in the directory header. We will obtain this information for each
// directory entry.
struct Entry {
uint32_t offset;
uint32_t size;
};
SkAutoTDeleteArray<Entry> directoryEntries(new Entry[numImages]);
// Iterate over directory entries
for (uint32_t i = 0; i < numImages; i++) {
// The directory entry contains information such as width, height,
// bits per pixel, and number of colors in the color palette. We will
// ignore these fields since they are repeated in the header of the
// embedded image. In the event of an inconsistency, we would always
// defer to the value in the embedded header anyway.
// Specifies the size of the embedded image, including the header
uint32_t size = get_int(entryBuffer.get(), 8 + i*kIcoDirEntryBytes);
// Specifies the offset of the embedded image from the start of file.
// It does not indicate the start of the pixel data, but rather the
// start of the embedded image header.
uint32_t offset = get_int(entryBuffer.get(), 12 + i*kIcoDirEntryBytes);
// Save the vital fields
directoryEntries.get()[i].offset = offset;
directoryEntries.get()[i].size = size;
}
// It is "customary" that the embedded images will be stored in order of
// increasing offset. However, the specification does not indicate that
// they must be stored in this order, so we will not trust that this is the
// case. Here we sort the embedded images by increasing offset.
struct EntryLessThan {
bool operator() (Entry a, Entry b) const {
return a.offset < b.offset;
}
};
EntryLessThan lessThan;
SkTQSort(directoryEntries.get(), directoryEntries.get() + numImages - 1,
lessThan);
// Now will construct a candidate codec for each of the embedded images
uint32_t bytesRead = kIcoDirectoryBytes + numImages * kIcoDirEntryBytes;
SkAutoTDelete<SkTArray<SkAutoTDelete<SkCodec>, true>> codecs(
new (SkTArray<SkAutoTDelete<SkCodec>, true>)(numImages));
for (uint32_t i = 0; i < numImages; i++) {
uint32_t offset = directoryEntries.get()[i].offset;
uint32_t size = directoryEntries.get()[i].size;
// Ensure that the offset is valid
if (offset < bytesRead) {
SkCodecPrintf("Warning: invalid ico offset.\n");
continue;
}
// If we cannot skip, assume we have reached the end of the stream and
// stop trying to make codecs
if (inputStream.get()->skip(offset - bytesRead) != offset - bytesRead) {
SkCodecPrintf("Warning: could not skip to ico offset.\n");
break;
}
bytesRead = offset;
// Create a new stream for the embedded codec
SkAutoTUnref<SkData> data(
SkData::NewFromStream(inputStream.get(), size));
if (nullptr == data.get()) {
SkCodecPrintf("Warning: could not create embedded stream.\n");
break;
}
SkAutoTDelete<SkMemoryStream> embeddedStream(new SkMemoryStream(data.get()));
bytesRead += size;
// Check if the embedded codec is bmp or png and create the codec
SkCodec* codec = nullptr;
if (SkPngCodec::IsPng((const char*) data->bytes(), data->size())) {
codec = SkPngCodec::NewFromStream(embeddedStream.detach());
} else {
codec = SkBmpCodec::NewFromIco(embeddedStream.detach());
}
// Save a valid codec
if (nullptr != codec) {
codecs->push_back().reset(codec);
}
}
// Recognize if there are no valid codecs
if (0 == codecs->count()) {
SkCodecPrintf("Error: could not find any valid embedded ico codecs.\n");
return nullptr;
}
// Use the largest codec as a "suggestion" for image info
uint32_t maxSize = 0;
uint32_t maxIndex = 0;
for (int32_t i = 0; i < codecs->count(); i++) {
SkImageInfo info = codecs->operator[](i)->getInfo();
uint32_t size = info.width() * info.height();
if (size > maxSize) {
maxSize = size;
maxIndex = i;
}
}
SkImageInfo info = codecs->operator[](maxIndex)->getInfo();
// ICOs contain an alpha mask after the image which means we cannot
// guarantee that an image is opaque, even if the sub-codec thinks it
// is.
// FIXME (msarett): The BMP decoder depends on the alpha type in order
// to decode correctly, otherwise it could report kUnpremul and we would
// not have to correct it here. Is there a better way?
// FIXME (msarett): This is only true for BMP in ICO - could a PNG in ICO
// be opaque? Is it okay that we missed out on the opportunity to mark
// such an image as opaque?
info = info.makeAlphaType(kUnpremul_SkAlphaType);
// Note that stream is owned by the embedded codec, the ico does not need
// direct access to the stream.
return new SkIcoCodec(info, codecs.detach());
}
/*
* Assumes IsIco was called and returned true
* Creates an Ico decoder
* Reads enough of the stream to determine the image format
*/
SkCodec* SkIcoCodec::NewFromStream(SkStream* stream) {
// Ensure that we do not leak the input stream
SkAutoTDelete<SkStream> inputStream(stream);
// Header size constants
static const uint32_t kIcoDirectoryBytes = 6;
static const uint32_t kIcoDirEntryBytes = 16;
// Read the directory header
SkAutoTDeleteArray<uint8_t> dirBuffer(
SkNEW_ARRAY(uint8_t, kIcoDirectoryBytes));
if (inputStream.get()->read(dirBuffer.get(), kIcoDirectoryBytes) !=
kIcoDirectoryBytes) {
SkCodecPrintf("Error: unable to read ico directory header.\n");
return NULL;
}
// Process the directory header
const uint16_t numImages = get_short(dirBuffer.get(), 4);
if (0 == numImages) {
SkCodecPrintf("Error: No images embedded in ico.\n");
return NULL;
}
// Ensure that we can read all of indicated directory entries
SkAutoTDeleteArray<uint8_t> entryBuffer(
SkNEW_ARRAY(uint8_t, numImages*kIcoDirEntryBytes));
if (inputStream.get()->read(entryBuffer.get(), numImages*kIcoDirEntryBytes) !=
numImages*kIcoDirEntryBytes) {
SkCodecPrintf("Error: unable to read ico directory entries.\n");
return NULL;
}
// This structure is used to represent the vital information about entries
// in the directory header. We will obtain this information for each
// directory entry.
struct Entry {
uint32_t offset;
uint32_t size;
};
SkAutoTDeleteArray<Entry> directoryEntries(SkNEW_ARRAY(Entry, numImages));
// Iterate over directory entries
for (uint32_t i = 0; i < numImages; i++) {
// The directory entry contains information such as width, height,
// bits per pixel, and number of colors in the color palette. We will
// ignore these fields since they are repeated in the header of the
// embedded image. In the event of an inconsistency, we would always
// defer to the value in the embedded header anyway.
// Specifies the size of the embedded image, including the header
uint32_t size = get_int(entryBuffer.get(), 8 + i*kIcoDirEntryBytes);
// Specifies the offset of the embedded image from the start of file.
// It does not indicate the start of the pixel data, but rather the
// start of the embedded image header.
uint32_t offset = get_int(entryBuffer.get(), 12 + i*kIcoDirEntryBytes);
// Save the vital fields
directoryEntries.get()[i].offset = offset;
directoryEntries.get()[i].size = size;
}
// It is "customary" that the embedded images will be stored in order of
// increasing offset. However, the specification does not indicate that
// they must be stored in this order, so we will not trust that this is the
// case. Here we sort the embedded images by increasing offset.
struct EntryLessThan {
bool operator() (Entry a, Entry b) const {
return a.offset < b.offset;
}
};
EntryLessThan lessThan;
SkTQSort(directoryEntries.get(), directoryEntries.get() + numImages - 1,
lessThan);
// Now will construct a candidate codec for each of the embedded images
uint32_t bytesRead = kIcoDirectoryBytes + numImages * kIcoDirEntryBytes;
SkAutoTDelete<SkTArray<SkAutoTDelete<SkCodec>, true>> codecs(
SkNEW_ARGS((SkTArray<SkAutoTDelete<SkCodec>, true>), (numImages)));
for (uint32_t i = 0; i < numImages; i++) {
uint32_t offset = directoryEntries.get()[i].offset;
uint32_t size = directoryEntries.get()[i].size;
// Ensure that the offset is valid
if (offset < bytesRead) {
SkCodecPrintf("Warning: invalid ico offset.\n");
continue;
}
// If we cannot skip, assume we have reached the end of the stream and
// stop trying to make codecs
if (inputStream.get()->skip(offset - bytesRead) != offset - bytesRead) {
SkCodecPrintf("Warning: could not skip to ico offset.\n");
break;
}
bytesRead = offset;
// Create a new stream for the embedded codec
SkAutoTUnref<SkData> data(
SkData::NewFromStream(inputStream.get(), size));
if (NULL == data.get()) {
SkCodecPrintf("Warning: could not create embedded stream.\n");
break;
}
SkAutoTDelete<SkMemoryStream>
embeddedStream(SkNEW_ARGS(SkMemoryStream, (data.get())));
bytesRead += size;
// Check if the embedded codec is bmp or png and create the codec
const bool isPng = SkPngCodec::IsPng(embeddedStream);
SkAssertResult(embeddedStream->rewind());
SkCodec* codec = NULL;
if (isPng) {
codec = SkPngCodec::NewFromStream(embeddedStream.detach());
} else {
codec = SkBmpCodec::NewFromIco(embeddedStream.detach());
}
// Save a valid codec
if (NULL != codec) {
codecs->push_back().reset(codec);
}
}
// Recognize if there are no valid codecs
if (0 == codecs->count()) {
SkCodecPrintf("Error: could not find any valid embedded ico codecs.\n");
return NULL;
}
// Use the largest codec as a "suggestion" for image info
uint32_t maxSize = 0;
uint32_t maxIndex = 0;
for (int32_t i = 0; i < codecs->count(); i++) {
SkImageInfo info = codecs->operator[](i)->getInfo();
uint32_t size = info.width() * info.height();
if (size > maxSize) {
maxSize = size;
maxIndex = i;
}
}
SkImageInfo info = codecs->operator[](maxIndex)->getInfo();
// Note that stream is owned by the embedded codec, the ico does not need
// direct access to the stream.
return SkNEW_ARGS(SkIcoCodec, (info, codecs.detach()));
}
