The Tor Browser / file revision

 /* -*- 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/DebugOnly.h"

 #include "mozilla/Endian.h"

 #include <stdint.h>

 #include "nsDebug.h"

 #include "MediaDecoderReader.h"

 #include "OggCodecState.h"

 #include "OggDecoder.h"

 #include "nsISupportsImpl.h"

 #include "VideoUtils.h"

 #include <algorithm>

 // 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 {

 #ifdef PR_LOGGING

 extern PRLogModuleInfo* gMediaDecoderLog;

 #define LOG(type, msg) PR_LOG(gMediaDecoderLog, type, msg)

 #else

 #define LOG(type, msg)

 #endif

 /** 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);

 #ifdef MOZ_OPUS

   } else if (aPage->body_len > 8 && memcmp(aPage->body, "OpusHead", 8) == 0) {

     codecState = new OpusState(aPage);

 #endif

   } else if (aPage->body_len > 8 && memcmp(aPage->body, "fishead\0", 8) == 0) {

     codecState = new SkeletonState(aPage);

   } else {

     codecState = new OggCodecState(aPage, false);

   }

   return codecState->OggCodecState::Init() ? 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::Init() {

   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(PR_LOG_DEBUG, ("Skipping comment: no separator"));

     return false;

   }

   nsCString key = nsCString(aComment, div-aComment);

   if (!IsValidVorbisTagName(key)) {

     LOG(PR_LOG_DEBUG, ("Skipping comment: invalid tag name"));

     return false;

   }

   uint32_t valueLength = aLength - (div-aComment);

   nsCString value = nsCString(div + 1, valueLength);

   if (!IsUTF8(value)) {

     LOG(PR_LOG_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);

 }

 ogg_packet* OggCodecState::PacketOut() {

   if (mPackets.IsEmpty()) {

     return nullptr;

   }

   return mPackets.PopFront();

 }

 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 == nullptr) {

     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::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;

 }

 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 = CheckedInt64(aGranulepos) * USECS_PER_S;

   if (!t.isValid())

     t = 0;

   return t.value() / aInfo->rate;

 }

 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[mUnstamped.Length()-1];

   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;

 }

 #ifdef MOZ_OPUS

 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(PR_LOG_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(PR_LOG_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 = CheckedInt64(aGranulepos - aPreSkip) * USECS_PER_S;

   return t.isValid() ? t.value() / 48000 : -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;

 }

 bool OpusState::ReconstructOpusGranulepos(void)

 {

   NS_ASSERTION(mUnstamped.Length() > 0, "Must have unstamped packets");

   ogg_packet* last = mUnstamped[mUnstamped.Length()-1];

   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;

 }

 #endif /* MOZ_OPUS */

 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 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;

 static bool IsSkeletonBOS(ogg_packet* aPacket)

 {

   return aPacket->bytes >= SKELETON_MIN_HEADER_LEN && 

          memcmp(reinterpret_cast<char*>(aPacket->packet), "fishead", 8) == 0;

 }

 static bool IsSkeletonIndex(ogg_packet* aPacket)

 {

   return aPacket->bytes >= SKELETON_4_0_MIN_INDEX_LEN &&

          memcmp(reinterpret_cast<char*>(aPacket->packet), "index", 5) == 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(PR_LOG_DEBUG, ("Ogg Skeleton Index packet for stream %u has 0 "

                        "timestamp denominator.", serialno));

     return (mActive = false);

   }

   // Extract the start time.

   CheckedInt64 t = CheckedInt64(LittleEndian::readInt64(p + INDEX_FIRST_NUMER_OFFSET)) * USECS_PER_S;

   if (!t.isValid()) {

     return (mActive = false);

   } else {

     startTime = t.value() / timeDenom;

   }

   // Extract the end time.

   t = LittleEndian::readInt64(p + INDEX_LAST_NUMER_OFFSET) * USECS_PER_S;

   if (!t.isValid()) {

     return (mActive = false);

   } else {

     endTime = t.value() / timeDenom;

   }

   // 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(PR_LOG_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 = time * USECS_PER_S;

     if (!timeUsecs.isValid())

       return mActive = false;

     timeUsecs /= timeDenom;

     keyPoints->Add(offset.value(), timeUsecs.value());

     numKeyPointsRead++;

   }

   int32_t keyPointsRead = keyPoints->Length();

   if (keyPointsRead > 0) {

     mIndex.Put(serialno, keyPoints.forget());

   }

   LOG(PR_LOG_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(PR_LOG_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::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(PR_LOG_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 (aPacket->e_o_s) {

     mDoneReadingHeaders = true;

     return true;

   }

   return true;

 }

 } // namespace mozilla