status_t SampleTable::findSyncSampleNear(
uint32_t start_sample_index, uint32_t *sample_index, uint32_t flags) {
Mutex::Autolock autoLock(mLock);
*sample_index = 0;
if (mSyncSampleOffset < 0) {
// All samples are sync-samples.
*sample_index = start_sample_index;
return OK;
}
if (mNumSyncSamples == 0) {
*sample_index = 0;
return OK;
}
uint32_t left = 0;
uint32_t right_plus_one = mNumSyncSamples;
while (left < right_plus_one) {
uint32_t center = left + (right_plus_one - left) / 2;
uint32_t x = mSyncSamples[center];
if (start_sample_index < x) {
right_plus_one = center;
} else if (start_sample_index > x) {
left = center + 1;
} else {
*sample_index = x;
return OK;
}
}
if (left == mNumSyncSamples) {
if (flags == kFlagAfter) {
ALOGE("tried to find a sync frame after the last one: %d", left);
return ERROR_OUT_OF_RANGE;
}
flags = kFlagBefore;
}
else if (left == 0) {
if (flags == kFlagBefore) {
ALOGE("tried to find a sync frame before the first one: %d", left);
// normally we should return out of range, but that is
// treated as end-of-stream. instead seek to first sync
//
// return ERROR_OUT_OF_RANGE;
}
flags = kFlagAfter;
}
// Now ssi[left - 1] <(=) start_sample_index <= ssi[left]
switch (flags) {
case kFlagBefore:
{
--left;
break;
}
case kFlagAfter:
{
// nothing to do
break;
}
default:
{
// this route is not used, but implement it nonetheless
CHECK(flags == kFlagClosest);
status_t err = mSampleIterator->seekTo(start_sample_index);
if (err != OK) {
return err;
}
uint32_t sample_time = mSampleIterator->getSampleTime();
err = mSampleIterator->seekTo(mSyncSamples[left]);
if (err != OK) {
return err;
}
uint32_t upper_time = mSampleIterator->getSampleTime();
err = mSampleIterator->seekTo(mSyncSamples[left - 1]);
if (err != OK) {
return err;
}
uint32_t lower_time = mSampleIterator->getSampleTime();
// use abs_difference for safety
if (abs_difference(upper_time, sample_time) >
abs_difference(sample_time, lower_time)) {
--left;
}
break;
}
}
*sample_index = mSyncSamples[left];
return OK;
}
status_t SampleTable::findSampleAtTime(
uint64_t req_time, uint64_t scale_num, uint64_t scale_den,
uint32_t *sample_index, uint32_t flags) {
buildSampleEntriesTable();
if (mSampleTimeEntries == NULL) {
return ERROR_OUT_OF_RANGE;
}
uint32_t left = 0;
uint32_t right_plus_one = mNumSampleSizes;
while (left < right_plus_one) {
uint32_t center = left + (right_plus_one - left) / 2;
uint64_t centerTime =
getSampleTime(center, scale_num, scale_den);
if (req_time < centerTime) {
right_plus_one = center;
} else if (req_time > centerTime) {
left = center + 1;
} else {
*sample_index = mSampleTimeEntries[center].mSampleIndex;
return OK;
}
}
uint32_t closestIndex = left;
if (closestIndex == mNumSampleSizes) {
if (flags == kFlagAfter) {
return ERROR_OUT_OF_RANGE;
}
flags = kFlagBefore;
} else if (closestIndex == 0) {
if (flags == kFlagBefore) {
// normally we should return out of range, but that is
// treated as end-of-stream. instead return first sample
//
// return ERROR_OUT_OF_RANGE;
}
flags = kFlagAfter;
}
switch (flags) {
case kFlagBefore:
{
--closestIndex;
break;
}
case kFlagAfter:
{
// nothing to do
break;
}
default:
{
CHECK(flags == kFlagClosest);
// pick closest based on timestamp. use abs_difference for safety
if (abs_difference(
getSampleTime(closestIndex, scale_num, scale_den), req_time) >
abs_difference(
req_time, getSampleTime(closestIndex - 1, scale_num, scale_den))) {
--closestIndex;
}
break;
}
}
*sample_index = mSampleTimeEntries[closestIndex].mSampleIndex;
return OK;
}
status_t SampleTable::findSampleAtTime(
uint32_t req_time, uint32_t *sample_index, uint32_t flags) {
buildSampleEntriesTable();
uint32_t left = 0;
uint32_t right = mNumSampleSizes;
while (left < right) {
uint32_t center = (left + right) / 2;
uint32_t centerTime = mSampleTimeEntries[center].mCompositionTime;
if (req_time < centerTime) {
right = center;
} else if (req_time > centerTime) {
left = center + 1;
} else {
left = center;
break;
}
}
if (left == mNumSampleSizes) {
if (flags == kFlagAfter) {
return ERROR_OUT_OF_RANGE;
}
--left;
}
uint32_t closestIndex = left;
switch (flags) {
case kFlagBefore:
{
while (closestIndex > 0
&& mSampleTimeEntries[closestIndex].mCompositionTime
> req_time) {
--closestIndex;
}
break;
}
case kFlagAfter:
{
while (closestIndex + 1 < mNumSampleSizes
&& mSampleTimeEntries[closestIndex].mCompositionTime
< req_time) {
++closestIndex;
}
break;
}
default:
{
CHECK(flags == kFlagClosest);
if (closestIndex > 0) {
// Check left neighbour and pick closest.
uint32_t absdiff1 =
abs_difference(
mSampleTimeEntries[closestIndex].mCompositionTime,
req_time);
uint32_t absdiff2 =
abs_difference(
mSampleTimeEntries[closestIndex - 1].mCompositionTime,
req_time);
if (absdiff1 > absdiff2) {
closestIndex = closestIndex - 1;
}
}
break;
}
}
*sample_index = mSampleTimeEntries[closestIndex].mSampleIndex;
return OK;
}
status_t SampleTable::findSyncSampleNear(
uint32_t start_sample_index, uint32_t *sample_index, uint32_t flags) {
Mutex::Autolock autoLock(mLock);
*sample_index = 0;
if (mSyncSampleOffset < 0) {
// All samples are sync-samples.
*sample_index = start_sample_index;
return OK;
}
if (mNumSyncSamples == 0) {
*sample_index = 0;
return OK;
}
uint32_t left = 0;
uint32_t right = mNumSyncSamples;
while (left < right) {
uint32_t center = left + (right - left) / 2;
uint32_t x = mSyncSamples[center];
if (start_sample_index < x) {
right = center;
} else if (start_sample_index > x) {
left = center + 1;
} else {
left = center;
break;
}
}
if (left == mNumSyncSamples) {
if (flags == kFlagAfter) {
ALOGE("tried to find a sync frame after the last one: %d", left);
return ERROR_OUT_OF_RANGE;
}
left = left - 1;
}
// Now ssi[left] is the sync sample index just before (or at)
// start_sample_index.
// Also start_sample_index < ssi[left + 1], if left + 1 < mNumSyncSamples.
uint32_t x = mSyncSamples[left];
if (left + 1 < mNumSyncSamples) {
uint32_t y = mSyncSamples[left + 1];
// our sample lies between sync samples x and y.
status_t err = mSampleIterator->seekTo(start_sample_index);
if (err != OK) {
return err;
}
uint32_t sample_time = mSampleIterator->getSampleTime();
err = mSampleIterator->seekTo(x);
if (err != OK) {
return err;
}
uint32_t x_time = mSampleIterator->getSampleTime();
err = mSampleIterator->seekTo(y);
if (err != OK) {
return err;
}
uint32_t y_time = mSampleIterator->getSampleTime();
if (abs_difference(x_time, sample_time)
> abs_difference(y_time, sample_time)) {
// Pick the sync sample closest (timewise) to the start-sample.
x = y;
++left;
}
}
switch (flags) {
case kFlagBefore:
{
if (x > start_sample_index) {
CHECK(left > 0);
x = mSyncSamples[left - 1];
if (x > start_sample_index) {
// The table of sync sample indices was not sorted
// properly.
return ERROR_MALFORMED;
}
}
break;
}
case kFlagAfter:
{
if (x < start_sample_index) {
if (left + 1 >= mNumSyncSamples) {
return ERROR_OUT_OF_RANGE;
}
x = mSyncSamples[left + 1];
if (x < start_sample_index) {
// The table of sync sample indices was not sorted
// properly.
return ERROR_MALFORMED;
}
}
break;
}
default:
break;
}
*sample_index = x;
return OK;
}
status_t SampleTable::findSyncSampleNear(
uint32_t start_sample_index, uint32_t *sample_index, uint32_t flags) {
Mutex::Autolock autoLock(mLock);
*sample_index = 0;
if (mSyncSampleOffset < 0) {
// All samples are sync-samples.
*sample_index = start_sample_index;
return OK;
}
if (mNumSyncSamples == 0) {
*sample_index = 0;
return OK;
}
uint32_t left = 0;
while (left < mNumSyncSamples) {
uint32_t x = mSyncSamples[left];
if (x >= start_sample_index) {
break;
}
++left;
}
if (left == mNumSyncSamples) {
if (flags == kFlagAfter) {
LOGE("tried to find a sync frame after the last one: %d", left);
return ERROR_OUT_OF_RANGE;
}
}
if (left > 0) {
--left;
}
uint32_t x = mSyncSamples[left];
if (left + 1 < mNumSyncSamples) {
uint32_t y = mSyncSamples[left + 1];
// our sample lies between sync samples x and y.
status_t err = mSampleIterator->seekTo(start_sample_index);
if (err != OK) {
return err;
}
uint32_t sample_time = mSampleIterator->getSampleTime();
err = mSampleIterator->seekTo(x);
if (err != OK) {
return err;
}
uint32_t x_time = mSampleIterator->getSampleTime();
err = mSampleIterator->seekTo(y);
if (err != OK) {
return err;
}
uint32_t y_time = mSampleIterator->getSampleTime();
if (abs_difference(x_time, sample_time)
> abs_difference(y_time, sample_time)) {
// Pick the sync sample closest (timewise) to the start-sample.
x = y;
++left;
}
}
switch (flags) {
case kFlagBefore:
{
if (x > start_sample_index) {
CHECK(left > 0);
x = mSyncSamples[left - 1];
CHECK(x <= start_sample_index);
}
break;
}
case kFlagAfter:
{
if (x < start_sample_index) {
if (left + 1 >= mNumSyncSamples) {
return ERROR_OUT_OF_RANGE;
}
x = mSyncSamples[left + 1];
CHECK(x >= start_sample_index);
}
break;
}
default:
break;
}
*sample_index = x;
return OK;
}
