/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim:set ts=2 sw=2 sts=2 et cindent: */ /* 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/. */ #include <string.h> #include "mozilla/EndianUtils.h" #include <stdint.h> #include "nsDebug.h" #include "OggCodecState.h" #include "OpusParser.h" #include "VideoUtils.h" #include <algorithm> #include <opus/opus.h> #include "opus/opus_multistream.h" // On Android JellyBean, the hardware.h header redefines version_major and // version_minor, which breaks our build. See: // https://bugzilla.mozilla.org/show_bug.cgi?id=912702#c6 #ifdef MOZ_WIDGET_GONK #ifdef version_major #undef version_major #endif #ifdef version_minor #undef version_minor #endif #endif namespace mozilla { extern LazyLogModule gMediaDecoderLog; #define LOG(type, msg) MOZ_LOG(gMediaDecoderLog, type, msg) /** Decoder base class for Ogg-encapsulated streams. */ OggCodecState* OggCodecState::Create(ogg_page* aPage) { NS_ASSERTION(ogg_page_bos(aPage), "Only call on BOS page!"); nsAutoPtr<OggCodecState> codecState; if (aPage->body_len > 6 && memcmp(aPage->body+1, "theora", 6) == 0) { codecState = new TheoraState(aPage); } else if (aPage->body_len > 6 && memcmp(aPage->body+1, "vorbis", 6) == 0) { codecState = new VorbisState(aPage); } else if (aPage->body_len > 8 && memcmp(aPage->body, "OpusHead", 8) == 0) { codecState = new OpusState(aPage); } else if (aPage->body_len > 8 && memcmp(aPage->body, "fishead\0", 8) == 0) { codecState = new SkeletonState(aPage); } else if (aPage->body_len > 5 && memcmp(aPage->body, "\177FLAC", 5) == 0) { codecState = new FlacState(aPage); } else { codecState = new OggCodecState(aPage, false); } return codecState->OggCodecState::InternalInit() ? codecState.forget() : nullptr; } OggCodecState::OggCodecState(ogg_page* aBosPage, bool aActive) : mPacketCount(0) , mSerial(ogg_page_serialno(aBosPage)) , mActive(aActive) , mDoneReadingHeaders(!aActive) { MOZ_COUNT_CTOR(OggCodecState); memset(&mState, 0, sizeof(ogg_stream_state)); } OggCodecState::~OggCodecState() { MOZ_COUNT_DTOR(OggCodecState); Reset(); #ifdef DEBUG int ret = #endif ogg_stream_clear(&mState); NS_ASSERTION(ret == 0, "ogg_stream_clear failed"); } nsresult OggCodecState::Reset() { if (ogg_stream_reset(&mState) != 0) { return NS_ERROR_FAILURE; } mPackets.Erase(); ClearUnstamped(); return NS_OK; } void OggCodecState::ClearUnstamped() { for (uint32_t i = 0; i < mUnstamped.Length(); ++i) { OggCodecState::ReleasePacket(mUnstamped[i]); } mUnstamped.Clear(); } bool OggCodecState::InternalInit() { int ret = ogg_stream_init(&mState, mSerial); return ret == 0; } bool OggCodecState::IsValidVorbisTagName(nsCString& aName) { // Tag names must consist of ASCII 0x20 through 0x7D, // excluding 0x3D '=' which is the separator. uint32_t length = aName.Length(); const char* data = aName.Data(); for (uint32_t i = 0; i < length; i++) { if (data[i] < 0x20 || data[i] > 0x7D || data[i] == '=') { return false; } } return true; } bool OggCodecState::AddVorbisComment(MetadataTags* aTags, const char* aComment, uint32_t aLength) { const char* div = (const char*)memchr(aComment, '=', aLength); if (!div) { LOG(LogLevel::Debug, ("Skipping comment: no separator")); return false; } nsCString key = nsCString(aComment, div-aComment); if (!IsValidVorbisTagName(key)) { LOG(LogLevel::Debug, ("Skipping comment: invalid tag name")); return false; } uint32_t valueLength = aLength - (div-aComment); nsCString value = nsCString(div + 1, valueLength); if (!IsUTF8(value)) { LOG(LogLevel::Debug, ("Skipping comment: invalid UTF-8 in value")); return false; } aTags->Put(key, value); return true; } void VorbisState::RecordVorbisPacketSamples(ogg_packet* aPacket, long aSamples) { #ifdef VALIDATE_VORBIS_SAMPLE_CALCULATION mVorbisPacketSamples[aPacket] = aSamples; #endif } void VorbisState::ValidateVorbisPacketSamples(ogg_packet* aPacket, long aSamples) { #ifdef VALIDATE_VORBIS_SAMPLE_CALCULATION NS_ASSERTION(mVorbisPacketSamples[aPacket] == aSamples, "Decoded samples for Vorbis packet don't match expected!"); mVorbisPacketSamples.erase(aPacket); #endif } void VorbisState::AssertHasRecordedPacketSamples(ogg_packet* aPacket) { #ifdef VALIDATE_VORBIS_SAMPLE_CALCULATION NS_ASSERTION(mVorbisPacketSamples.count(aPacket) == 1, "Must have recorded packet samples"); #endif } static ogg_packet* Clone(ogg_packet* aPacket) { ogg_packet* p = new ogg_packet(); memcpy(p, aPacket, sizeof(ogg_packet)); p->packet = new unsigned char[p->bytes]; memcpy(p->packet, aPacket->packet, p->bytes); return p; } void OggCodecState::ReleasePacket(ogg_packet* aPacket) { if (aPacket) delete [] aPacket->packet; delete aPacket; } void OggPacketQueue::Append(ogg_packet* aPacket) { nsDeque::Push(aPacket); } bool OggCodecState::IsPacketReady() { return !mPackets.IsEmpty(); } ogg_packet* OggCodecState::PacketOut() { if (mPackets.IsEmpty()) { return nullptr; } return mPackets.PopFront(); } ogg_packet* OggCodecState::PacketPeek() { if (mPackets.IsEmpty()) { return nullptr; } return mPackets.PeekFront(); } void OggCodecState::PushFront(OggPacketQueue &&aOther) { while (!aOther.IsEmpty()) { mPackets.PushFront(aOther.Pop()); } } already_AddRefed<MediaRawData> OggCodecState::PacketOutAsMediaRawData() { ogg_packet* packet = PacketOut(); if (!packet) { return nullptr; } NS_ASSERTION(!IsHeader(packet), "PacketOutAsMediaRawData can only be called on non-header packets"); RefPtr<MediaRawData> sample = new MediaRawData(packet->packet, packet->bytes); if (packet->bytes && !sample->Data()) { // OOM. ReleasePacket(packet); return nullptr; } int64_t end_tstamp = Time(packet->granulepos); NS_ASSERTION(end_tstamp >= 0, "timestamp invalid"); int64_t duration = PacketDuration(packet); NS_ASSERTION(duration >= 0, "duration invalid"); sample->mTimecode = packet->granulepos; sample->mTime = end_tstamp - duration; sample->mDuration = duration; sample->mKeyframe = IsKeyframe(packet); sample->mEOS = packet->e_o_s; ReleasePacket(packet); return sample.forget(); } nsresult OggCodecState::PageIn(ogg_page* aPage) { if (!mActive) { return NS_OK; } NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial, "Page must be for this stream!"); if (ogg_stream_pagein(&mState, aPage) == -1) { return NS_ERROR_FAILURE; } int r; do { ogg_packet packet; r = ogg_stream_packetout(&mState, &packet); if (r == 1) { mPackets.Append(Clone(&packet)); } } while (r != 0); if (ogg_stream_check(&mState)) { NS_WARNING("Unrecoverable error in ogg_stream_packetout"); return NS_ERROR_FAILURE; } return NS_OK; } nsresult OggCodecState::PacketOutUntilGranulepos(bool& aFoundGranulepos) { int r; aFoundGranulepos = false; // Extract packets from the sync state until either no more packets // come out, or we get a data packet with non -1 granulepos. do { ogg_packet packet; r = ogg_stream_packetout(&mState, &packet); if (r == 1) { ogg_packet* clone = Clone(&packet); if (IsHeader(&packet)) { // Header packets go straight into the packet queue. mPackets.Append(clone); } else { // We buffer data packets until we encounter a granulepos. We'll // then use the granulepos to figure out the granulepos of the // preceeding packets. mUnstamped.AppendElement(clone); aFoundGranulepos = packet.granulepos > 0; } } } while (r != 0 && !aFoundGranulepos); if (ogg_stream_check(&mState)) { NS_WARNING("Unrecoverable error in ogg_stream_packetout"); return NS_ERROR_FAILURE; } return NS_OK; } TheoraState::TheoraState(ogg_page* aBosPage) : OggCodecState(aBosPage, true) , mSetup(0) , mCtx(0) , mPixelAspectRatio(0) { MOZ_COUNT_CTOR(TheoraState); th_info_init(&mInfo); th_comment_init(&mComment); } TheoraState::~TheoraState() { MOZ_COUNT_DTOR(TheoraState); th_setup_free(mSetup); th_decode_free(mCtx); th_comment_clear(&mComment); th_info_clear(&mInfo); } bool TheoraState::Init() { if (!mActive) { return false; } int64_t n = mInfo.aspect_numerator; int64_t d = mInfo.aspect_denominator; mPixelAspectRatio = (n == 0 || d == 0) ? 1.0f : static_cast<float>(n) / static_cast<float>(d); // Ensure the frame and picture regions aren't larger than our prescribed // maximum, or zero sized. nsIntSize frame(mInfo.frame_width, mInfo.frame_height); nsIntRect picture(mInfo.pic_x, mInfo.pic_y, mInfo.pic_width, mInfo.pic_height); if (!IsValidVideoRegion(frame, picture, frame)) { return mActive = false; } mCtx = th_decode_alloc(&mInfo, mSetup); if (!mCtx) { return mActive = false; } return true; } bool TheoraState::DecodeHeader(ogg_packet* aPacket) { nsAutoRef<ogg_packet> autoRelease(aPacket); mPacketCount++; int ret = th_decode_headerin(&mInfo, &mComment, &mSetup, aPacket); // We must determine when we've read the last header packet. // th_decode_headerin() does not tell us when it's read the last header, so // we must keep track of the headers externally. // // There are 3 header packets, the Identification, Comment, and Setup // headers, which must be in that order. If they're out of order, the file // is invalid. If we've successfully read a header, and it's the setup // header, then we're done reading headers. The first byte of each packet // determines it's type as follows: // 0x80 -> Identification header // 0x81 -> Comment header // 0x82 -> Setup header // See http://www.theora.org/doc/Theora.pdf Chapter 6, "Bitstream Headers", // for more details of the Ogg/Theora containment scheme. bool isSetupHeader = aPacket->bytes > 0 && aPacket->packet[0] == 0x82; if (ret < 0 || mPacketCount > 3) { // We've received an error, or the first three packets weren't valid // header packets. Assume bad input. // Our caller will deactivate the bitstream. return false; } else if (ret > 0 && isSetupHeader && mPacketCount == 3) { // Successfully read the three header packets. mDoneReadingHeaders = true; } return true; } int64_t TheoraState::Time(int64_t granulepos) { if (!mActive) { return -1; } return TheoraState::Time(&mInfo, granulepos); } bool TheoraState::IsHeader(ogg_packet* aPacket) { return th_packet_isheader(aPacket); } # define TH_VERSION_CHECK(_info,_maj,_min,_sub) \ (((_info)->version_major>(_maj)||(_info)->version_major==(_maj))&& \ (((_info)->version_minor>(_min)||(_info)->version_minor==(_min))&& \ (_info)->version_subminor>=(_sub))) int64_t TheoraState::Time(th_info* aInfo, int64_t aGranulepos) { if (aGranulepos < 0 || aInfo->fps_numerator == 0) { return -1; } // Implementation of th_granule_frame inlined here to operate // on the th_info structure instead of the theora_state. int shift = aInfo->keyframe_granule_shift; ogg_int64_t iframe = aGranulepos >> shift; ogg_int64_t pframe = aGranulepos - (iframe << shift); int64_t frameno = iframe + pframe - TH_VERSION_CHECK(aInfo, 3, 2, 1); CheckedInt64 t = ((CheckedInt64(frameno) + 1) * USECS_PER_S) * aInfo->fps_denominator; if (!t.isValid()) { return -1; } t /= aInfo->fps_numerator; return t.isValid() ? t.value() : -1; } int64_t TheoraState::StartTime(int64_t granulepos) { if (granulepos < 0 || !mActive || mInfo.fps_numerator == 0) { return -1; } CheckedInt64 t = (CheckedInt64(th_granule_frame(mCtx, granulepos)) * USECS_PER_S) * mInfo.fps_denominator; if (!t.isValid()) { return -1; } return t.value() / mInfo.fps_numerator; } int64_t TheoraState::PacketDuration(ogg_packet* aPacket) { if (!mActive || mInfo.fps_numerator == 0) { return -1; } CheckedInt64 t = SaferMultDiv(mInfo.fps_denominator, USECS_PER_S, mInfo.fps_numerator); return t.isValid() ? t.value() : -1; } int64_t TheoraState::MaxKeyframeOffset() { // Determine the maximum time in microseconds by which a key frame could // offset for the theora bitstream. Theora granulepos encode time as: // ((key_frame_number << granule_shift) + frame_offset). // Therefore the maximum possible time by which any frame could be offset // from a keyframe is the duration of (1 << granule_shift) - 1) frames. int64_t frameDuration; // Max number of frames keyframe could possibly be offset. int64_t keyframeDiff = (1 << mInfo.keyframe_granule_shift) - 1; // Length of frame in usecs. frameDuration = (mInfo.fps_denominator * USECS_PER_S) / mInfo.fps_numerator; // Total time in usecs keyframe can be offset from any given frame. return frameDuration * keyframeDiff; } bool TheoraState::IsKeyframe(ogg_packet* pkt) { // first bit of packet is 1 for header, 0 for data // second bit of packet is 1 for inter frame, 0 for intra frame return (pkt->bytes >= 1 && (pkt->packet[0] & 0x40) == 0x00); } nsresult TheoraState::PageIn(ogg_page* aPage) { if (!mActive) return NS_OK; NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial, "Page must be for this stream!"); if (ogg_stream_pagein(&mState, aPage) == -1) return NS_ERROR_FAILURE; bool foundGp; nsresult res = PacketOutUntilGranulepos(foundGp); if (NS_FAILED(res)) return res; if (foundGp && mDoneReadingHeaders) { // We've found a packet with a granulepos, and we've loaded our metadata // and initialized our decoder. Determine granulepos of buffered packets. ReconstructTheoraGranulepos(); for (uint32_t i = 0; i < mUnstamped.Length(); ++i) { ogg_packet* packet = mUnstamped[i]; #ifdef DEBUG NS_ASSERTION(!IsHeader(packet), "Don't try to recover header packet gp"); NS_ASSERTION(packet->granulepos != -1, "Packet must have gp by now"); #endif mPackets.Append(packet); } mUnstamped.Clear(); } return NS_OK; } // Returns 1 if the Theora info struct is decoding a media of Theora // version (maj,min,sub) or later, otherwise returns 0. int TheoraVersion(th_info* info, unsigned char maj, unsigned char min, unsigned char sub) { ogg_uint32_t ver = (maj << 16) + (min << 8) + sub; ogg_uint32_t th_ver = (info->version_major << 16) + (info->version_minor << 8) + info->version_subminor; return (th_ver >= ver) ? 1 : 0; } void TheoraState::ReconstructTheoraGranulepos() { if (mUnstamped.Length() == 0) { return; } ogg_int64_t lastGranulepos = mUnstamped[mUnstamped.Length() - 1]->granulepos; NS_ASSERTION(lastGranulepos != -1, "Must know last granulepos"); // Reconstruct the granulepos (and thus timestamps) of the decoded // frames. Granulepos are stored as ((keyframe<<shift)+offset). We // know the granulepos of the last frame in the list, so we can infer // the granulepos of the intermediate frames using their frame numbers. ogg_int64_t shift = mInfo.keyframe_granule_shift; ogg_int64_t version_3_2_1 = TheoraVersion(&mInfo,3,2,1); ogg_int64_t lastFrame = th_granule_frame(mCtx, lastGranulepos) + version_3_2_1; ogg_int64_t firstFrame = lastFrame - mUnstamped.Length() + 1; // Until we encounter a keyframe, we'll assume that the "keyframe" // segment of the granulepos is the first frame, or if that causes // the "offset" segment to overflow, we assume the required // keyframe is maximumally offset. Until we encounter a keyframe // the granulepos will probably be wrong, but we can't decode the // frame anyway (since we don't have its keyframe) so it doesn't really // matter. ogg_int64_t keyframe = lastGranulepos >> shift; // The lastFrame, firstFrame, keyframe variables, as well as the frame // variable in the loop below, store the frame number for Theora // version >= 3.2.1 streams, and store the frame index for Theora // version < 3.2.1 streams. for (uint32_t i = 0; i < mUnstamped.Length() - 1; ++i) { ogg_int64_t frame = firstFrame + i; ogg_int64_t granulepos; ogg_packet* packet = mUnstamped[i]; bool isKeyframe = th_packet_iskeyframe(packet) == 1; if (isKeyframe) { granulepos = frame << shift; keyframe = frame; } else if (frame >= keyframe && frame - keyframe < ((ogg_int64_t)1 << shift)) { // (frame - keyframe) won't overflow the "offset" segment of the // granulepos, so it's safe to calculate the granulepos. granulepos = (keyframe << shift) + (frame - keyframe); } else { // (frame - keyframeno) will overflow the "offset" segment of the // granulepos, so we take "keyframe" to be the max possible offset // frame instead. ogg_int64_t k = std::max(frame - (((ogg_int64_t)1 << shift) - 1), version_3_2_1); granulepos = (k << shift) + (frame - k); } // Theora 3.2.1+ granulepos store frame number [1..N], so granulepos // should be > 0. // Theora 3.2.0 granulepos store the frame index [0..(N-1)], so // granulepos should be >= 0. NS_ASSERTION(granulepos >= version_3_2_1, "Invalid granulepos for Theora version"); // Check that the frame's granule number is one more than the // previous frame's. NS_ASSERTION(i == 0 || th_granule_frame(mCtx, granulepos) == th_granule_frame(mCtx, mUnstamped[i-1]->granulepos) + 1, "Granulepos calculation is incorrect!"); packet->granulepos = granulepos; } // Check that the second to last frame's granule number is one less than // the last frame's (the known granule number). If not our granulepos // recovery missed a beat. NS_ASSERTION(mUnstamped.Length() < 2 || th_granule_frame(mCtx, mUnstamped[mUnstamped.Length()-2]->granulepos) + 1 == th_granule_frame(mCtx, lastGranulepos), "Granulepos recovery should catch up with packet->granulepos!"); } nsresult VorbisState::Reset() { nsresult res = NS_OK; if (mActive && vorbis_synthesis_restart(&mDsp) != 0) { res = NS_ERROR_FAILURE; } if (NS_FAILED(OggCodecState::Reset())) { return NS_ERROR_FAILURE; } mGranulepos = 0; mPrevVorbisBlockSize = 0; return res; } VorbisState::VorbisState(ogg_page* aBosPage) : OggCodecState(aBosPage, true) , mPrevVorbisBlockSize(0) , mGranulepos(0) { MOZ_COUNT_CTOR(VorbisState); vorbis_info_init(&mInfo); vorbis_comment_init(&mComment); memset(&mDsp, 0, sizeof(vorbis_dsp_state)); memset(&mBlock, 0, sizeof(vorbis_block)); } VorbisState::~VorbisState() { MOZ_COUNT_DTOR(VorbisState); Reset(); vorbis_block_clear(&mBlock); vorbis_dsp_clear(&mDsp); vorbis_info_clear(&mInfo); vorbis_comment_clear(&mComment); } bool VorbisState::DecodeHeader(ogg_packet* aPacket) { nsAutoRef<ogg_packet> autoRelease(aPacket); mPacketCount++; int ret = vorbis_synthesis_headerin(&mInfo, &mComment, aPacket); // We must determine when we've read the last header packet. // vorbis_synthesis_headerin() does not tell us when it's read the last // header, so we must keep track of the headers externally. // // There are 3 header packets, the Identification, Comment, and Setup // headers, which must be in that order. If they're out of order, the file // is invalid. If we've successfully read a header, and it's the setup // header, then we're done reading headers. The first byte of each packet // determines it's type as follows: // 0x1 -> Identification header // 0x3 -> Comment header // 0x5 -> Setup header // For more details of the Vorbis/Ogg containment scheme, see the Vorbis I // Specification, Chapter 4, Codec Setup and Packet Decode: // http://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-580004 bool isSetupHeader = aPacket->bytes > 0 && aPacket->packet[0] == 0x5; if (ret < 0 || mPacketCount > 3) { // We've received an error, or the first three packets weren't valid // header packets. Assume bad input. Our caller will deactivate the // bitstream. return false; } else if (ret == 0 && isSetupHeader && mPacketCount == 3) { // Successfully read the three header packets. // The bitstream remains active. mDoneReadingHeaders = true; } return true; } bool VorbisState::Init() { if (!mActive) { return false; } int ret = vorbis_synthesis_init(&mDsp, &mInfo); if (ret != 0) { NS_WARNING("vorbis_synthesis_init() failed initializing vorbis bitstream"); return mActive = false; } ret = vorbis_block_init(&mDsp, &mBlock); if (ret != 0) { NS_WARNING("vorbis_block_init() failed initializing vorbis bitstream"); if (mActive) { vorbis_dsp_clear(&mDsp); } return mActive = false; } return true; } int64_t VorbisState::Time(int64_t granulepos) { if (!mActive) { return -1; } return VorbisState::Time(&mInfo, granulepos); } int64_t VorbisState::Time(vorbis_info* aInfo, int64_t aGranulepos) { if (aGranulepos == -1 || aInfo->rate == 0) { return -1; } CheckedInt64 t = SaferMultDiv(aGranulepos, USECS_PER_S, aInfo->rate); return t.isValid() ? t.value() : 0; } int64_t VorbisState::PacketDuration(ogg_packet* aPacket) { if (!mActive) { return -1; } if (aPacket->granulepos == -1) { return -1; } // @FIXME store these in a more stable place if (mVorbisPacketSamples.count(aPacket) == 0) { // We haven't seen this packet, don't know its size? return -1; } long samples = mVorbisPacketSamples[aPacket]; return Time(samples); } bool VorbisState::IsHeader(ogg_packet* aPacket) { // The first byte in each Vorbis header packet is either 0x01, 0x03, or 0x05, // i.e. the first bit is odd. Audio data packets have their first bit as 0x0. // Any packet with its first bit set cannot be a data packet, it's a // (possibly invalid) header packet. // See: http://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-610004.2.1 return aPacket->bytes > 0 ? (aPacket->packet[0] & 0x1) : false; } MetadataTags* VorbisState::GetTags() { MetadataTags* tags; NS_ASSERTION(mComment.user_comments, "no vorbis comment strings!"); NS_ASSERTION(mComment.comment_lengths, "no vorbis comment lengths!"); tags = new MetadataTags; for (int i = 0; i < mComment.comments; i++) { AddVorbisComment(tags, mComment.user_comments[i], mComment.comment_lengths[i]); } return tags; } nsresult VorbisState::PageIn(ogg_page* aPage) { if (!mActive) { return NS_OK; } NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial, "Page must be for this stream!"); if (ogg_stream_pagein(&mState, aPage) == -1) return NS_ERROR_FAILURE; bool foundGp; nsresult res = PacketOutUntilGranulepos(foundGp); if (NS_FAILED(res)) { return res; } if (foundGp && mDoneReadingHeaders) { // We've found a packet with a granulepos, and we've loaded our metadata // and initialized our decoder. Determine granulepos of buffered packets. ReconstructVorbisGranulepos(); for (uint32_t i = 0; i < mUnstamped.Length(); ++i) { ogg_packet* packet = mUnstamped[i]; AssertHasRecordedPacketSamples(packet); NS_ASSERTION(!IsHeader(packet), "Don't try to recover header packet gp"); NS_ASSERTION(packet->granulepos != -1, "Packet must have gp by now"); mPackets.Append(packet); } mUnstamped.Clear(); } return NS_OK; } nsresult VorbisState::ReconstructVorbisGranulepos() { // The number of samples in a Vorbis packet is: // window_blocksize(previous_packet)/4+window_blocksize(current_packet)/4 // See: http://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-230001.3.2 // So we maintain mPrevVorbisBlockSize, the block size of the last packet // encountered. We also maintain mGranulepos, which is the granulepos of // the last encountered packet. This enables us to give granulepos to // packets when the last packet in mUnstamped doesn't have a granulepos // (for example if the stream was truncated). // // We validate our prediction of the number of samples decoded when // VALIDATE_VORBIS_SAMPLE_CALCULATION is defined by recording the predicted // number of samples, and verifing we extract that many when decoding // each packet. NS_ASSERTION(mUnstamped.Length() > 0, "Length must be > 0"); ogg_packet* last = mUnstamped.LastElement(); NS_ASSERTION(last->e_o_s || last->granulepos >= 0, "Must know last granulepos!"); if (mUnstamped.Length() == 1) { ogg_packet* packet = mUnstamped[0]; long blockSize = vorbis_packet_blocksize(&mInfo, packet); if (blockSize < 0) { // On failure vorbis_packet_blocksize returns < 0. If we've got // a bad packet, we just assume that decode will have to skip this // packet, i.e. assume 0 samples are decodable from this packet. blockSize = 0; mPrevVorbisBlockSize = 0; } long samples = mPrevVorbisBlockSize / 4 + blockSize / 4; mPrevVorbisBlockSize = blockSize; if (packet->granulepos == -1) { packet->granulepos = mGranulepos + samples; } // Account for a partial last frame if (packet->e_o_s && packet->granulepos >= mGranulepos) { samples = packet->granulepos - mGranulepos; } mGranulepos = packet->granulepos; RecordVorbisPacketSamples(packet, samples); return NS_OK; } bool unknownGranulepos = last->granulepos == -1; int totalSamples = 0; for (int32_t i = mUnstamped.Length() - 1; i > 0; i--) { ogg_packet* packet = mUnstamped[i]; ogg_packet* prev = mUnstamped[i-1]; ogg_int64_t granulepos = packet->granulepos; NS_ASSERTION(granulepos != -1, "Must know granulepos!"); long prevBlockSize = vorbis_packet_blocksize(&mInfo, prev); long blockSize = vorbis_packet_blocksize(&mInfo, packet); if (blockSize < 0 || prevBlockSize < 0) { // On failure vorbis_packet_blocksize returns < 0. If we've got // a bad packet, we just assume that decode will have to skip this // packet, i.e. assume 0 samples are decodable from this packet. blockSize = 0; prevBlockSize = 0; } long samples = prevBlockSize / 4 + blockSize / 4; totalSamples += samples; prev->granulepos = granulepos - samples; RecordVorbisPacketSamples(packet, samples); } if (unknownGranulepos) { for (uint32_t i = 0; i < mUnstamped.Length(); i++) { ogg_packet* packet = mUnstamped[i]; packet->granulepos += mGranulepos + totalSamples + 1; } } ogg_packet* first = mUnstamped[0]; long blockSize = vorbis_packet_blocksize(&mInfo, first); if (blockSize < 0) { mPrevVorbisBlockSize = 0; blockSize = 0; } long samples = (mPrevVorbisBlockSize == 0) ? 0 : mPrevVorbisBlockSize / 4 + blockSize / 4; int64_t start = first->granulepos - samples; RecordVorbisPacketSamples(first, samples); if (last->e_o_s && start < mGranulepos) { // We've calculated that there are more samples in this page than its // granulepos claims, and it's the last page in the stream. This is legal, // and we will need to prune the trailing samples when we come to decode it. // We must correct the timestamps so that they follow the last Vorbis page's // samples. int64_t pruned = mGranulepos - start; for (uint32_t i = 0; i < mUnstamped.Length() - 1; i++) { mUnstamped[i]->granulepos += pruned; } #ifdef VALIDATE_VORBIS_SAMPLE_CALCULATION mVorbisPacketSamples[last] -= pruned; #endif } mPrevVorbisBlockSize = vorbis_packet_blocksize(&mInfo, last); mPrevVorbisBlockSize = std::max(static_cast<long>(0), mPrevVorbisBlockSize); mGranulepos = last->granulepos; return NS_OK; } OpusState::OpusState(ogg_page* aBosPage) : OggCodecState(aBosPage, true) , mParser(nullptr) , mDecoder(nullptr) , mSkip(0) , mPrevPacketGranulepos(0) , mPrevPageGranulepos(0) { MOZ_COUNT_CTOR(OpusState); } OpusState::~OpusState() { MOZ_COUNT_DTOR(OpusState); Reset(); if (mDecoder) { opus_multistream_decoder_destroy(mDecoder); mDecoder = nullptr; } } nsresult OpusState::Reset() { return Reset(false); } nsresult OpusState::Reset(bool aStart) { nsresult res = NS_OK; if (mActive && mDecoder) { // Reset the decoder. opus_multistream_decoder_ctl(mDecoder, OPUS_RESET_STATE); // Let the seek logic handle pre-roll if we're not seeking to the start. mSkip = aStart ? mParser->mPreSkip : 0; // This lets us distinguish the first page being the last page vs. just // not having processed the previous page when we encounter the last page. mPrevPageGranulepos = aStart ? 0 : -1; mPrevPacketGranulepos = aStart ? 0 : -1; } // Clear queued data. if (NS_FAILED(OggCodecState::Reset())) { return NS_ERROR_FAILURE; } LOG(LogLevel::Debug, ("Opus decoder reset, to skip %d", mSkip)); return res; } bool OpusState::Init(void) { if (!mActive) { return false; } int error; NS_ASSERTION(mDecoder == nullptr, "leaking OpusDecoder"); mDecoder = opus_multistream_decoder_create(mParser->mRate, mParser->mChannels, mParser->mStreams, mParser->mCoupledStreams, mParser->mMappingTable, &error); mSkip = mParser->mPreSkip; LOG(LogLevel::Debug, ("Opus decoder init, to skip %d", mSkip)); return error == OPUS_OK; } bool OpusState::DecodeHeader(ogg_packet* aPacket) { nsAutoRef<ogg_packet> autoRelease(aPacket); switch(mPacketCount++) { // Parse the id header. case 0: mParser = new OpusParser; if (!mParser->DecodeHeader(aPacket->packet, aPacket->bytes)) { return false; } mRate = mParser->mRate; mChannels = mParser->mChannels; mPreSkip = mParser->mPreSkip; #ifdef MOZ_SAMPLE_TYPE_FLOAT32 mGain = mParser->mGain; #else mGain_Q16 = mParser->mGain_Q16; #endif break; // Parse the metadata header. case 1: if (!mParser->DecodeTags(aPacket->packet, aPacket->bytes)) { return false; } break; // We made it to the first data packet (which includes reconstructing // timestamps for it in PageIn). Success! default: mDoneReadingHeaders = true; // Put it back on the queue so we can decode it. mPackets.PushFront(autoRelease.disown()); break; } return true; } /* Construct and return a tags hashmap from our internal array */ MetadataTags* OpusState::GetTags() { MetadataTags* tags; tags = new MetadataTags; for (uint32_t i = 0; i < mParser->mTags.Length(); i++) { AddVorbisComment(tags, mParser->mTags[i].Data(), mParser->mTags[i].Length()); } return tags; } /* Return the timestamp (in microseconds) equivalent to a granulepos. */ int64_t OpusState::Time(int64_t aGranulepos) { if (!mActive) { return -1; } return Time(mParser->mPreSkip, aGranulepos); } int64_t OpusState::Time(int aPreSkip, int64_t aGranulepos) { if (aGranulepos < 0) { return -1; } // Ogg Opus always runs at a granule rate of 48 kHz. CheckedInt64 t = SaferMultDiv(aGranulepos - aPreSkip, USECS_PER_S, 48000); return t.isValid() ? t.value() : -1; } bool OpusState::IsHeader(ogg_packet* aPacket) { return aPacket->bytes >= 16 && (!memcmp(aPacket->packet, "OpusHead", 8) || !memcmp(aPacket->packet, "OpusTags", 8)); } nsresult OpusState::PageIn(ogg_page* aPage) { if (!mActive) { return NS_OK; } NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial, "Page must be for this stream!"); if (ogg_stream_pagein(&mState, aPage) == -1) return NS_ERROR_FAILURE; bool haveGranulepos; nsresult rv = PacketOutUntilGranulepos(haveGranulepos); if (NS_FAILED(rv) || !haveGranulepos || mPacketCount < 2) { return rv; } if (!ReconstructOpusGranulepos()) { return NS_ERROR_FAILURE; } for (uint32_t i = 0; i < mUnstamped.Length(); i++) { ogg_packet* packet = mUnstamped[i]; NS_ASSERTION(!IsHeader(packet), "Don't try to play a header packet"); NS_ASSERTION(packet->granulepos != -1, "Packet should have a granulepos"); mPackets.Append(packet); } mUnstamped.Clear(); return NS_OK; } // Helper method to return the change in granule position due to an Opus packet // (as distinct from the number of samples in the packet, which depends on the // decoder rate). It should work with a multistream Opus file, and continue to // work should we ever allow the decoder to decode at a rate other than 48 kHz. // It even works before we've created the actual Opus decoder. static int GetOpusDeltaGP(ogg_packet* packet) { int nframes; nframes = opus_packet_get_nb_frames(packet->packet, packet->bytes); if (nframes > 0) { return nframes*opus_packet_get_samples_per_frame(packet->packet, 48000); } NS_WARNING("Invalid Opus packet."); return nframes; } int64_t OpusState::PacketDuration(ogg_packet* aPacket) { CheckedInt64 t = SaferMultDiv(GetOpusDeltaGP(aPacket), USECS_PER_S, 48000); return t.isValid() ? t.value() : -1; } bool OpusState::ReconstructOpusGranulepos(void) { NS_ASSERTION(mUnstamped.Length() > 0, "Must have unstamped packets"); ogg_packet* last = mUnstamped.LastElement(); NS_ASSERTION(last->e_o_s || last->granulepos > 0, "Must know last granulepos!"); int64_t gp; // If this is the last page, and we've seen at least one previous page (or // this is the first page)... if (last->e_o_s) { if (mPrevPageGranulepos != -1) { // If this file only has one page and the final granule position is // smaller than the pre-skip amount, we MUST reject the stream. if (!mDoneReadingHeaders && last->granulepos < mPreSkip) return false; int64_t last_gp = last->granulepos; gp = mPrevPageGranulepos; // Loop through the packets forwards, adding the current packet's // duration to the previous granulepos to get the value for the // current packet. for (uint32_t i = 0; i < mUnstamped.Length() - 1; ++i) { ogg_packet* packet = mUnstamped[i]; int offset = GetOpusDeltaGP(packet); // Check for error (negative offset) and overflow. if (offset >= 0 && gp <= INT64_MAX - offset) { gp += offset; if (gp >= last_gp) { NS_WARNING("Opus end trimming removed more than a full packet."); // We were asked to remove a full packet's worth of data or more. // Encoders SHOULD NOT produce streams like this, but we'll handle // it for them anyway. gp = last_gp; for (uint32_t j = i+1; j < mUnstamped.Length(); ++j) { OggCodecState::ReleasePacket(mUnstamped[j]); } mUnstamped.RemoveElementsAt(i+1, mUnstamped.Length() - (i+1)); last = packet; last->e_o_s = 1; } } packet->granulepos = gp; } mPrevPageGranulepos = last_gp; return true; } else { NS_WARNING("No previous granule position to use for Opus end trimming."); // If we don't have a previous granule position, fall through. // We simply won't trim any samples from the end. // TODO: Are we guaranteed to have seen a previous page if there is one? } } gp = last->granulepos; // Loop through the packets backwards, subtracting the next // packet's duration from its granulepos to get the value // for the current packet. for (uint32_t i = mUnstamped.Length() - 1; i > 0; i--) { int offset = GetOpusDeltaGP(mUnstamped[i]); // Check for error (negative offset) and overflow. if (offset >= 0) { if (offset <= gp) { gp -= offset; } else { // If the granule position of the first data page is smaller than the // number of decodable audio samples on that page, then we MUST reject // the stream. if (!mDoneReadingHeaders) return false; // It's too late to reject the stream. // If we get here, this almost certainly means the file has screwed-up // timestamps somewhere after the first page. NS_WARNING("Clamping negative Opus granulepos to zero."); gp = 0; } } mUnstamped[i - 1]->granulepos = gp; } // Check to make sure the first granule position is at least as large as the // total number of samples decodable from the first page with completed // packets. This requires looking at the duration of the first packet, too. // We MUST reject such streams. if (!mDoneReadingHeaders && GetOpusDeltaGP(mUnstamped[0]) > gp) { return false; } mPrevPageGranulepos = last->granulepos; return true; } already_AddRefed<MediaRawData> OpusState::PacketOutAsMediaRawData() { ogg_packet* packet = PacketPeek(); uint32_t frames = 0; const int64_t endFrame = packet->granulepos; if (!packet) { return nullptr; } if (packet->e_o_s) { frames = GetOpusDeltaGP(packet); } RefPtr<MediaRawData> data = OggCodecState::PacketOutAsMediaRawData(); if (!data) { return nullptr; } if (data->mEOS && mPrevPacketGranulepos != -1) { // If this is the last packet, perform end trimming. int64_t startFrame = mPrevPacketGranulepos; frames -= std::max<int64_t>( 0, std::min(endFrame - startFrame, static_cast<int64_t>(frames))); data->mDiscardPadding = frames; } // Save this packet's granule position in case we need to perform end // trimming on the next packet. mPrevPacketGranulepos = endFrame; return data.forget(); } FlacState::FlacState(ogg_page* aBosPage) : OggCodecState(aBosPage, true) { } bool FlacState::DecodeHeader(ogg_packet* aPacket) { nsAutoRef<ogg_packet> autoRelease(aPacket); if (!mParser.DecodeHeaderBlock(aPacket->packet, aPacket->bytes)) { return false; } if (mParser.HasFullMetadata()) { mDoneReadingHeaders = true; } return true; } int64_t FlacState::Time(int64_t granulepos) { if (!mParser.mInfo.IsValid()) { return -1; } CheckedInt64 t = SaferMultDiv(granulepos, USECS_PER_S, mParser.mInfo.mRate); if (!t.isValid()) { return -1; } return t.value(); } int64_t FlacState::PacketDuration(ogg_packet* aPacket) { return mParser.BlockDuration(aPacket->packet, aPacket->bytes); } bool FlacState::IsHeader(ogg_packet* aPacket) { return mParser.IsHeaderBlock(aPacket->packet, aPacket->bytes); } nsresult FlacState::PageIn(ogg_page* aPage) { if (!mActive) { return NS_OK; } NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial, "Page must be for this stream!"); if (ogg_stream_pagein(&mState, aPage) == -1) return NS_ERROR_FAILURE; bool foundGp; nsresult res = PacketOutUntilGranulepos(foundGp); if (NS_FAILED(res)) { return res; } if (foundGp && mDoneReadingHeaders) { // We've found a packet with a granulepos, and we've loaded our metadata // and initialized our decoder. Determine granulepos of buffered packets. ReconstructFlacGranulepos(); for (uint32_t i = 0; i < mUnstamped.Length(); ++i) { ogg_packet* packet = mUnstamped[i]; NS_ASSERTION(!IsHeader(packet), "Don't try to recover header packet gp"); NS_ASSERTION(packet->granulepos != -1, "Packet must have gp by now"); mPackets.Append(packet); } mUnstamped.Clear(); } return NS_OK; } // Return a hash table with tag metadata. MetadataTags* FlacState::GetTags() { return mParser.GetTags(); } const AudioInfo& FlacState::Info() { return mParser.mInfo; } bool FlacState::ReconstructFlacGranulepos(void) { NS_ASSERTION(mUnstamped.Length() > 0, "Must have unstamped packets"); ogg_packet* last = mUnstamped.LastElement(); NS_ASSERTION(last->e_o_s || last->granulepos > 0, "Must know last granulepos!"); int64_t gp; gp = last->granulepos; // Loop through the packets backwards, subtracting the next // packet's duration from its granulepos to get the value // for the current packet. for (uint32_t i = mUnstamped.Length() - 1; i > 0; i--) { int offset = mParser.BlockDuration(mUnstamped[i]->packet, mUnstamped[i]->bytes); // Check for error (negative offset) and overflow. if (offset >= 0) { if (offset <= gp) { gp -= offset; } else { // If the granule position of the first data page is smaller than the // number of decodable audio samples on that page, then we MUST reject // the stream. if (!mDoneReadingHeaders) { return false; } // It's too late to reject the stream. // If we get here, this almost certainly means the file has screwed-up // timestamps somewhere after the first page. NS_WARNING("Clamping negative granulepos to zero."); gp = 0; } } mUnstamped[i - 1]->granulepos = gp; } return true; } SkeletonState::SkeletonState(ogg_page* aBosPage) : OggCodecState(aBosPage, true) , mVersion(0) , mPresentationTime(0) , mLength(0) { MOZ_COUNT_CTOR(SkeletonState); } SkeletonState::~SkeletonState() { MOZ_COUNT_DTOR(SkeletonState); } // Support for Ogg Skeleton 4.0, as per specification at: // http://wiki.xiph.org/Ogg_Skeleton_4 // Minimum length in bytes of a Skeleton header packet. static const long SKELETON_MIN_HEADER_LEN = 28; static const long SKELETON_4_0_MIN_HEADER_LEN = 80; // Minimum length in bytes of a Skeleton 4.0 index packet. static const long SKELETON_4_0_MIN_INDEX_LEN = 42; // Minimum length in bytes of a Skeleton 3.0/4.0 Fisbone packet. static const long SKELETON_MIN_FISBONE_LEN = 52; // Minimum possible size of a compressed index keypoint. static const size_t MIN_KEY_POINT_SIZE = 2; // Byte offset of the major and minor version numbers in the // Ogg Skeleton 4.0 header packet. static const size_t SKELETON_VERSION_MAJOR_OFFSET = 8; static const size_t SKELETON_VERSION_MINOR_OFFSET = 10; // Byte-offsets of the presentation time numerator and denominator static const size_t SKELETON_PRESENTATION_TIME_NUMERATOR_OFFSET = 12; static const size_t SKELETON_PRESENTATION_TIME_DENOMINATOR_OFFSET = 20; // Byte-offsets of the length of file field in the Skeleton 4.0 header packet. static const size_t SKELETON_FILE_LENGTH_OFFSET = 64; // Byte-offsets of the fields in the Skeleton index packet. static const size_t INDEX_SERIALNO_OFFSET = 6; static const size_t INDEX_NUM_KEYPOINTS_OFFSET = 10; static const size_t INDEX_TIME_DENOM_OFFSET = 18; static const size_t INDEX_FIRST_NUMER_OFFSET = 26; static const size_t INDEX_LAST_NUMER_OFFSET = 34; static const size_t INDEX_KEYPOINT_OFFSET = 42; // Byte-offsets of the fields in the Skeleton Fisbone packet. static const size_t FISBONE_MSG_FIELDS_OFFSET = 8; static const size_t FISBONE_SERIALNO_OFFSET = 12; static bool IsSkeletonBOS(ogg_packet* aPacket) { static_assert(SKELETON_MIN_HEADER_LEN >= 8, "Minimum length of skeleton BOS header incorrect"); return aPacket->bytes >= SKELETON_MIN_HEADER_LEN && memcmp(reinterpret_cast<char*>(aPacket->packet), "fishead", 8) == 0; } static bool IsSkeletonIndex(ogg_packet* aPacket) { static_assert(SKELETON_4_0_MIN_INDEX_LEN >= 5, "Minimum length of skeleton index header incorrect"); return aPacket->bytes >= SKELETON_4_0_MIN_INDEX_LEN && memcmp(reinterpret_cast<char*>(aPacket->packet), "index", 5) == 0; } static bool IsSkeletonFisbone(ogg_packet* aPacket) { static_assert(SKELETON_MIN_FISBONE_LEN >= 8, "Minimum length of skeleton fisbone header incorrect"); return aPacket->bytes >= SKELETON_MIN_FISBONE_LEN && memcmp(reinterpret_cast<char*>(aPacket->packet), "fisbone", 8) == 0; } // Reads a variable length encoded integer at p. Will not read // past aLimit. Returns pointer to character after end of integer. static const unsigned char* ReadVariableLengthInt(const unsigned char* p, const unsigned char* aLimit, int64_t& n) { int shift = 0; int64_t byte = 0; n = 0; while (p < aLimit && (byte & 0x80) != 0x80 && shift < 57) { byte = static_cast<int64_t>(*p); n |= ((byte & 0x7f) << shift); shift += 7; p++; } return p; } bool SkeletonState::DecodeIndex(ogg_packet* aPacket) { NS_ASSERTION(aPacket->bytes >= SKELETON_4_0_MIN_INDEX_LEN, "Index must be at least minimum size"); if (!mActive) { return false; } uint32_t serialno = LittleEndian::readUint32(aPacket->packet + INDEX_SERIALNO_OFFSET); int64_t numKeyPoints = LittleEndian::readInt64(aPacket->packet + INDEX_NUM_KEYPOINTS_OFFSET); int64_t endTime = 0, startTime = 0; const unsigned char* p = aPacket->packet; int64_t timeDenom = LittleEndian::readInt64(aPacket->packet + INDEX_TIME_DENOM_OFFSET); if (timeDenom == 0) { LOG(LogLevel::Debug, ("Ogg Skeleton Index packet for stream %u has 0 " "timestamp denominator.", serialno)); return (mActive = false); } // Extract the start time. int64_t timeRawInt = LittleEndian::readInt64(p + INDEX_FIRST_NUMER_OFFSET); CheckedInt64 t = SaferMultDiv(timeRawInt, USECS_PER_S, timeDenom); if (!t.isValid()) { return (mActive = false); } else { startTime = t.value(); } // Extract the end time. timeRawInt = LittleEndian::readInt64(p + INDEX_LAST_NUMER_OFFSET); t = SaferMultDiv(timeRawInt, USECS_PER_S, timeDenom); if (!t.isValid()) { return (mActive = false); } else { endTime = t.value(); } // Check the numKeyPoints value read, ensure we're not going to run out of // memory while trying to decode the index packet. CheckedInt64 minPacketSize = (CheckedInt64(numKeyPoints) * MIN_KEY_POINT_SIZE) + INDEX_KEYPOINT_OFFSET; if (!minPacketSize.isValid()) { return (mActive = false); } int64_t sizeofIndex = aPacket->bytes - INDEX_KEYPOINT_OFFSET; int64_t maxNumKeyPoints = sizeofIndex / MIN_KEY_POINT_SIZE; if (aPacket->bytes < minPacketSize.value() || numKeyPoints > maxNumKeyPoints || numKeyPoints < 0) { // Packet size is less than the theoretical minimum size, or the packet is // claiming to store more keypoints than it's capable of storing. This means // that the numKeyPoints field is too large or small for the packet to // possibly contain as many packets as it claims to, so the numKeyPoints // field is possibly malicious. Don't try decoding this index, we may run // out of memory. LOG(LogLevel::Debug, ("Possibly malicious number of key points reported " "(%lld) in index packet for stream %u.", numKeyPoints, serialno)); return (mActive = false); } nsAutoPtr<nsKeyFrameIndex> keyPoints(new nsKeyFrameIndex(startTime, endTime)); p = aPacket->packet + INDEX_KEYPOINT_OFFSET; const unsigned char* limit = aPacket->packet + aPacket->bytes; int64_t numKeyPointsRead = 0; CheckedInt64 offset = 0; CheckedInt64 time = 0; while (p < limit && numKeyPointsRead < numKeyPoints) { int64_t delta = 0; p = ReadVariableLengthInt(p, limit, delta); offset += delta; if (p == limit || !offset.isValid() || offset.value() > mLength || offset.value() < 0) { return (mActive = false); } p = ReadVariableLengthInt(p, limit, delta); time += delta; if (!time.isValid() || time.value() > endTime || time.value() < startTime) { return (mActive = false); } CheckedInt64 timeUsecs = SaferMultDiv(time.value(), USECS_PER_S, timeDenom); if (!timeUsecs.isValid()) { return (mActive = false); } keyPoints->Add(offset.value(), timeUsecs.value()); numKeyPointsRead++; } int32_t keyPointsRead = keyPoints->Length(); if (keyPointsRead > 0) { mIndex.Put(serialno, keyPoints.forget()); } LOG(LogLevel::Debug, ("Loaded %d keypoints for Skeleton on stream %u", keyPointsRead, serialno)); return true; } nsresult SkeletonState::IndexedSeekTargetForTrack(uint32_t aSerialno, int64_t aTarget, nsKeyPoint& aResult) { nsKeyFrameIndex* index = nullptr; mIndex.Get(aSerialno, &index); if (!index || index->Length() == 0 || aTarget < index->mStartTime || aTarget > index->mEndTime) { return NS_ERROR_FAILURE; } // Binary search to find the last key point with time less than target. int start = 0; int end = index->Length() - 1; while (end > start) { int mid = start + ((end - start + 1) >> 1); if (index->Get(mid).mTime == aTarget) { start = mid; break; } else if (index->Get(mid).mTime < aTarget) { start = mid; } else { end = mid - 1; } } aResult = index->Get(start); NS_ASSERTION(aResult.mTime <= aTarget, "Result should have time <= target"); return NS_OK; } nsresult SkeletonState::IndexedSeekTarget(int64_t aTarget, nsTArray<uint32_t>& aTracks, nsSeekTarget& aResult) { if (!mActive || mVersion < SKELETON_VERSION(4,0)) { return NS_ERROR_FAILURE; } // Loop over all requested tracks' indexes, and get the keypoint for that // seek target. Record the keypoint with the lowest offset, this will be // our seek result. User must seek to the one with lowest offset to ensure we // pass "keyframes" on all tracks when we decode forwards to the seek target. nsSeekTarget r; for (uint32_t i=0; i<aTracks.Length(); i++) { nsKeyPoint k; if (NS_SUCCEEDED(IndexedSeekTargetForTrack(aTracks[i], aTarget, k)) && k.mOffset < r.mKeyPoint.mOffset) { r.mKeyPoint = k; r.mSerial = aTracks[i]; } } if (r.IsNull()) { return NS_ERROR_FAILURE; } LOG(LogLevel::Debug, ("Indexed seek target for time %lld is offset %lld", aTarget, r.mKeyPoint.mOffset)); aResult = r; return NS_OK; } nsresult SkeletonState::GetDuration(const nsTArray<uint32_t>& aTracks, int64_t& aDuration) { if (!mActive || mVersion < SKELETON_VERSION(4,0) || !HasIndex() || aTracks.Length() == 0) { return NS_ERROR_FAILURE; } int64_t endTime = INT64_MIN; int64_t startTime = INT64_MAX; for (uint32_t i=0; i<aTracks.Length(); i++) { nsKeyFrameIndex* index = nullptr; mIndex.Get(aTracks[i], &index); if (!index) { // Can't get the timestamps for one of the required tracks, fail. return NS_ERROR_FAILURE; } if (index->mEndTime > endTime) { endTime = index->mEndTime; } if (index->mStartTime < startTime) { startTime = index->mStartTime; } } NS_ASSERTION(endTime > startTime, "Duration must be positive"); CheckedInt64 duration = CheckedInt64(endTime) - startTime; aDuration = duration.isValid() ? duration.value() : 0; return duration.isValid() ? NS_OK : NS_ERROR_FAILURE; } bool SkeletonState::DecodeFisbone(ogg_packet* aPacket) { if (aPacket->bytes < static_cast<long>(FISBONE_MSG_FIELDS_OFFSET + 4)) { return false; } uint32_t offsetMsgField = LittleEndian::readUint32(aPacket->packet + FISBONE_MSG_FIELDS_OFFSET); if (aPacket->bytes < static_cast<long>(FISBONE_SERIALNO_OFFSET + 4)) { return false; } uint32_t serialno = LittleEndian::readUint32(aPacket->packet + FISBONE_SERIALNO_OFFSET); CheckedUint32 checked_fields_pos = CheckedUint32(FISBONE_MSG_FIELDS_OFFSET) + offsetMsgField; if (!checked_fields_pos.isValid() || aPacket->bytes < static_cast<int64_t>(checked_fields_pos.value())) { return false; } int64_t msgLength = aPacket->bytes - checked_fields_pos.value(); char* msgProbe = (char*)aPacket->packet + checked_fields_pos.value(); char* msgHead = msgProbe; nsAutoPtr<MessageField> field(new MessageField()); const static FieldPatternType kFieldTypeMaps[] = { {"Content-Type:", eContentType}, {"Role:", eRole}, {"Name:", eName}, {"Language:", eLanguage}, {"Title:", eTitle}, {"Display-hint:", eDisplayHint}, {"Altitude:", eAltitude}, {"TrackOrder:", eTrackOrder}, {"Track dependencies:", eTrackDependencies} }; bool isContentTypeParsed = false; while (msgLength > 1) { if (*msgProbe == '\r' && *(msgProbe+1) == '\n') { nsAutoCString strMsg(msgHead, msgProbe-msgHead); for (size_t i = 0; i < ArrayLength(kFieldTypeMaps); i++) { if (strMsg.Find(kFieldTypeMaps[i].mPatternToRecognize) != -1) { // The content of message header fields follows [RFC2822], and the // mandatory message field must be encoded in US-ASCII, others // must be be encoded in UTF-8. "Content-Type" must come first // for all of message header fields. // See http://svn.annodex.net/standards/draft-pfeiffer-oggskeleton-current.txt. if (i != 0 && !isContentTypeParsed) { return false; } if ((i == 0 && IsASCII(strMsg)) || (i != 0 && IsUTF8(strMsg))) { EMsgHeaderType eHeaderType = kFieldTypeMaps[i].mMsgHeaderType; if (!field->mValuesStore.Contains(eHeaderType)) { uint32_t nameLen = strlen(kFieldTypeMaps[i].mPatternToRecognize); field->mValuesStore.Put(eHeaderType, new nsCString(msgHead+nameLen, msgProbe-msgHead-nameLen)); } isContentTypeParsed = i==0 ? true : isContentTypeParsed; } break; } } msgProbe += 2; msgLength -= 2; msgHead = msgProbe; continue; } msgLength--; msgProbe++; } if (!mMsgFieldStore.Contains(serialno)) { mMsgFieldStore.Put(serialno, field.forget()); } else { return false; } return true; } bool SkeletonState::DecodeHeader(ogg_packet* aPacket) { nsAutoRef<ogg_packet> autoRelease(aPacket); if (IsSkeletonBOS(aPacket)) { uint16_t verMajor = LittleEndian::readUint16(aPacket->packet + SKELETON_VERSION_MAJOR_OFFSET); uint16_t verMinor = LittleEndian::readUint16(aPacket->packet + SKELETON_VERSION_MINOR_OFFSET); // Read the presentation time. We read this before the version check as the // presentation time exists in all versions. int64_t n = LittleEndian::readInt64(aPacket->packet + SKELETON_PRESENTATION_TIME_NUMERATOR_OFFSET); int64_t d = LittleEndian::readInt64(aPacket->packet + SKELETON_PRESENTATION_TIME_DENOMINATOR_OFFSET); mPresentationTime = d == 0 ? 0 : (static_cast<float>(n) / static_cast<float>(d)) * USECS_PER_S; mVersion = SKELETON_VERSION(verMajor, verMinor); // We can only care to parse Skeleton version 4.0+. if (mVersion < SKELETON_VERSION(4,0) || mVersion >= SKELETON_VERSION(5,0) || aPacket->bytes < SKELETON_4_0_MIN_HEADER_LEN) { return false; } // Extract the segment length. mLength = LittleEndian::readInt64(aPacket->packet + SKELETON_FILE_LENGTH_OFFSET); LOG(LogLevel::Debug, ("Skeleton segment length: %lld", mLength)); // Initialize the serialno-to-index map. return true; } else if (IsSkeletonIndex(aPacket) && mVersion >= SKELETON_VERSION(4,0)) { return DecodeIndex(aPacket); } else if (IsSkeletonFisbone(aPacket)) { return DecodeFisbone(aPacket); } else if (aPacket->e_o_s) { mDoneReadingHeaders = true; return true; } return true; } } // namespace mozilla