Attachment #520042 for bug #639391

Attachment #520042: Patch 4: Ensure Ogg GetBuffered() is threadsafe for bug #639391

View | Details | Raw Unified | Return to bug 639391
Collapse All | Expand All





  return endTime;
}

nsresult nsOggReader::GetSeekRanges(nsTArray<SeekRange>& aRanges)
{
  NS_ASSERTION(mDecoder->OnStateMachineThread(),
               "Should be on state machine thread.");
  mMonitor.AssertCurrentThreadIn();
  nsTArray<nsByteRange> cached;
  nsresult res = mDecoder->GetCurrentStream()->GetCachedRanges(cached);
  NS_ENSURE_SUCCESS(res, res);

  for (PRUint32 index = 0; index < aRanges.Length(); index++) {
    nsByteRange& range = cached[index];
    PRInt64 startTime = -1;
    PRInt64 endTime = -1;
    if (NS_FAILED(ResetDecode())) {
      return NS_ERROR_FAILURE;
        break;
      }
    } else {
      // Bytes [startOffset..endOffset] are cached.
      PRInt64 startTime = -1;
      PRInt64 endTime = -1;
      if (NS_FAILED(ResetDecode())) {
        return NS_ERROR_FAILURE;
      }
      FindStartTime(startOffset, startTime);
      if (startTime != -1 &&
          ((endTime = FindEndTime(endOffset)) != -1))
      {
        NS_ASSERTION(startOffset < endOffset,
                     "Start offset must be before end offset");
        NS_ASSERTION(startTime < endTime,
                     "Start time must be before end time");
        aRanges.AppendElement(SeekRange(startOffset,
                                        endOffset,
                                        startTime,
                                        endTime));
      }
    }
    // Ensure the offsets are after the header pages.
    PRInt64 startOffset = NS_MAX(cached[index].mStart, mDataOffset);
    PRInt64 endOffset = NS_MAX(cached[index].mEnd, mDataOffset);

    FindStartTime(startOffset, startTime);
    if (startTime != -1 &&
        ((endTime = FindEndTime(endOffset)) != -1))
    {
      NS_ASSERTION(startTime < endTime,
                   "Start time must be before end time");
      aRanges.AppendElement(SeekRange(startOffset,
                                      endOffset,
                                      startTime,
                                      endTime));
     }
  }
  if (NS_FAILED(ResetDecode())) {
    return NS_ERROR_FAILURE;
  }
  return NS_OK;
}

nsOggReader::SeekRange

  // after metadata is read and GetBuffered isn't called before metadata is
  // read.
  if (!mInfo.mHasVideo && !mInfo.mHasAudio) {
    // No need to search through the file if there are no audio or video tracks
    return NS_OK;
  }

  nsMediaStream* stream = mDecoder->GetCurrentStream();
  nsTArray<nsByteRange> ranges;
  nsresult res = stream->GetCachedRanges(ranges);
  NS_ENSURE_SUCCESS(res, res);

  // Traverse across the buffered byte ranges, determining the time ranges
  // they contain. nsMediaStream::GetNextCachedData(offset) returns -1 when
  // offset is after the end of the media stream, or there's no more cached
  // data after the offset. This loop will run until we've checked every
  // buffered range in the media, in increasing order of offset.
  ogg_sync_state state;
  ogg_sync_init(&state);
  for (PRUint32 index = 0; index < ranges.Length(); index++) {
    // Ensure the offsets are after the header pages.
    PRInt64 startOffset = NS_MAX(ranges[index].mStart, mDataOffset);
    PRInt64 endOffset = NS_MAX(ranges[index].mEnd, mDataOffset);
    // Bytes [startOffset..endOffset] are cached.

    // Because the granulepos time is actually the end time of the page,
    // we special-case (startOffset == mDataOffset) so that the first
    // buffered range always appears to be buffered from the media start
    // time, rather than from the end-time of the first page.
    PRInt64 startTime = (startOffset == mDataOffset) ? aStartTime : -1;

    // Find the start time of the range. Read pages until we find one with a
    // granulepos which we can convert into a timestamp to use as the time of
    // the start of the buffered range.
    // Read pages until we find one with a granulepos which we can convert
    // into a timestamp to use as the time of the start of the buffered range.
    ogg_sync_reset(&state);
    while (startTime == -1) {
      ogg_page page;
      PRInt32 discard;
      PageSyncResult res = PageSync(stream,
                                    &state,
                                    PR_TRUE,
                                    startOffset,

        // Stream is not the theora or vorbis stream we're playing,
        // but is one that we have header data for.
        startOffset += page.header_len + page.body_len;
        continue;
      }
      else {
        // Page is for a stream we don't know about (possibly a chained
        // ogg), return an error.
        ogg_sync_clear(&state);
        return PAGE_SYNC_ERROR;
      }
    }

    if (startTime != -1) {
      // We were able to find a start time for that range, see if we can
      // find an end time.
      PRInt64 endTime = FindEndTime(startOffset, endOffset, PR_TRUE, &state);
      if (endTime != -1) {
        endTime -= aStartTime;
        aBuffered->Add(static_cast<double>(startTime) / 1000.0,
                       static_cast<double>(endTime) / 1000.0);
      }
    }
    startOffset = stream->GetNextCachedData(endOffset);
    NS_ASSERTION(startOffset == -1 || startOffset > endOffset,
      "Must have advanced to start of next range, or hit end of stream");
  }

  // If we don't clear the sync state before exit we'll leak.
  ogg_sync_clear(&state);

  return NS_OK;
}


Return to bug 639391