void
PacketTest :: testCopyPacket()
{
packet = IPacket::make();
VS_TUT_ENSURE("was able to allocate packet", packet);
// everything else should be garbage.
int64_t position = packet->getPosition();
VS_TUT_ENSURE("position was not set to -1", position == -1);
position = 4;
packet->setPosition(position);
int64_t dts = 28349762;
packet->setDts(dts);
int64_t pts = 82729373;
packet->setPts(pts);
RefPointer<IRational> timeBase = IRational::make(3,28972);
packet->setTimeBase(timeBase.value());
int32_t streamIndex = 8;
packet->setStreamIndex(streamIndex);
int64_t duration = 28387728;
packet->setDuration(duration);
int64_t convergenceDuration = 283;
packet->setConvergenceDuration(convergenceDuration);
// Now, make a copy
RefPointer<IPacket> newPacket = IPacket::make(packet.value(), false);
VS_TUT_ENSURE("should not be empty", newPacket);
VS_TUT_ENSURE_EQUALS("should equal", position, newPacket->getPosition());
VS_TUT_ENSURE_EQUALS("should equal", pts, newPacket->getPts());
VS_TUT_ENSURE_EQUALS("should equal", dts, newPacket->getDts());
VS_TUT_ENSURE_EQUALS("should equal", streamIndex, newPacket->getStreamIndex());
VS_TUT_ENSURE_EQUALS("should equal", duration, newPacket->getDuration());
VS_TUT_ENSURE_EQUALS("should equal", convergenceDuration,
newPacket->getConvergenceDuration());
RefPointer<IRational> newBase = newPacket->getTimeBase();
VS_TUT_ENSURE("should be equal", newBase->compareTo(timeBase.value()) == 0);
}
void
MediaPacketTest::testCopyPacket() {
const int32_t size = 512;
packet = MediaPacket::make(size);
TSM_ASSERT("was able to allocate packet", packet);
// everything else should be garbage.
int64_t position = packet->getPosition();
TSM_ASSERT("position was not set to -1", position == -1);
position = 4;
packet->setPosition(position);
int64_t dts = 28349762;
packet->setDts(dts);
int64_t pts = 82729373;
packet->setPts(pts);
RefPointer<Rational> timeBase = Rational::make(3, 28972);
packet->setTimeBase(timeBase.value());
int32_t streamIndex = 8;
packet->setStreamIndex(streamIndex);
int64_t duration = 28387728;
packet->setDuration(duration);
int64_t convergenceDuration = 283;
packet->setConvergenceDuration(convergenceDuration);
// let's get access to the data
RefPointer<Buffer> data = packet->getData();
TS_ASSERT_EQUALS(size+16, data->getBufferSize());
TS_ASSERT_EQUALS(size, packet->getSize());
uint8_t* raw = (uint8_t*) data->getBytes(0, size);
for (int i = 0; i < size; i++)
raw[i] = i % 16;
// Now, make a copy
bool tests[] =
{ true, false };
for (size_t i = 0; i < (sizeof(tests) / sizeof(tests[0])); i++) {
RefPointer<MediaPacket> newPacket = MediaPacket::make(packet.value(), tests[i]);
TSM_ASSERT("should not be empty", newPacket);
// let's make sure that when not copying, the data is the same.
TSM_ASSERT_EQUALS("should equal", position, newPacket->getPosition());
TSM_ASSERT_EQUALS("should equal", pts, newPacket->getPts());
TSM_ASSERT_EQUALS("should equal", dts, newPacket->getDts());
TSM_ASSERT_EQUALS("should equal", streamIndex, newPacket->getStreamIndex());
TSM_ASSERT_EQUALS("should equal", duration, newPacket->getDuration());
TSM_ASSERT_EQUALS("should equal", convergenceDuration,
newPacket->getConvergenceDuration());
RefPointer<Rational> newBase = newPacket->getTimeBase();
TSM_ASSERT("should be equal", newBase->compareTo(timeBase.value()) == 0);
RefPointer<Buffer> buf = newPacket->getData();
TS_ASSERT_EQUALS(size, newPacket->getSize());
TS_ASSERT_EQUALS(size+16, buf->getBufferSize());
uint8_t* d = (uint8_t*) buf->getBytes(0, size);
if (!tests[i]) {
TS_ASSERT_EQUALS(d, raw);
} else {
TS_ASSERT_DIFFERS(d, raw);
}
TS_ASSERT(d);
for (int j = 0; j < size; j++) {
TS_ASSERT_EQUALS(d[j], j % 16);
}
}
}
void
StreamCoderTest :: testDecodingAndEncodingFullyInterleavedFile()
{
RefPointer<IAudioSamples> samples = 0;
RefPointer<IVideoPicture> frame = 0;
RefPointer<IRational> num(0);
RefPointer<IStreamCoder> ic(0);
RefPointer<IStreamCoder> oc(0);
int numSamples = 0;
int numPackets = 0;
int numFrames = 0;
int numKeyFrames = 0;
int retval = -1;
h->setupReading(h->SAMPLE_FILE);
RefPointer<IPacket> packet = IPacket::make();
hw->setupWriting("StreamCoderTest_6_output.mov", "mpeg4", "libmp3lame", "mov");
RefPointer<IPacket> opacket = IPacket::make();
VS_TUT_ENSURE("! opacket", opacket);
RefPointer<IMetaData> inputProps = IMetaData::make();
RefPointer<IMetaData> outputProps = IMetaData::make();
{
// Let's set up audio first.
ic = h->coders[h->first_input_audio_stream];
oc = hw->coders[hw->first_output_audio_stream];
// Set the output coder correctly.
oc->setSampleRate(ic->getSampleRate());
oc->setChannels(ic->getChannels());
// Using the MetaData structure
char tmpBuf[1024];
snprintf(tmpBuf, sizeof(tmpBuf), "%d", ic->getBitRate());
inputProps->setValue("b", tmpBuf);
const char* invalidKey="kd82jclkjdi2oc001,ss2-948";
const char* invalidValue="c9xu1nxL28fJ9";
inputProps->setValue(invalidKey, invalidValue);
samples = IAudioSamples::make(1024, ic->getChannels());
VS_TUT_ENSURE("got no samples", samples);
retval = ic->open(0,0);
VS_TUT_ENSURE("Could not open input coder", retval >= 0);
retval = oc->open(inputProps.value(), outputProps.value());
VS_TUT_ENSURE("Could not open output coder", retval >= 0);
// now let's ensure our fake property was not set.
VS_TUT_ENSURE("Should only have one unset setting", outputProps->getNumKeys() == 1)
VS_TUT_ENSURE("Should have expected value", strcmp(outputProps->getValue(invalidKey, IMetaData::METADATA_NONE), invalidValue)==0);
}
{
// now, let's set up video.
ic = h->coders[h->first_input_video_stream];
oc = hw->coders[hw->first_output_video_stream];
// We're going to set up high quality video
oc->setBitRate(720000);
oc->setGlobalQuality(0);
oc->setFlags(oc->getFlags() | IStreamCoder::FLAG_QSCALE);
oc->setPixelType(ic->getPixelType());
oc->setHeight(ic->getHeight());
oc->setWidth(ic->getWidth());
num = IRational::make(1,15);
oc->setFrameRate(num.value());
num = ic->getTimeBase();
oc->setTimeBase(num.value());
oc->setNumPicturesInGroupOfPictures(
ic->getNumPicturesInGroupOfPictures()
);
// Ask the StreamCoder to guess width and height for us
frame = IVideoPicture::make(
ic->getPixelType(),
-1, -1);
VS_TUT_ENSURE("got no frame", frame);
VS_TUT_ENSURE("should not have width", frame->getWidth() <= 0);
VS_TUT_ENSURE("should not have height", frame->getHeight() <= 0);
retval = ic->open();
VS_TUT_ENSURE("Could not open input coder", retval >= 0);
retval = oc->open();
VS_TUT_ENSURE("Could not open output coder", retval >= 0);
}
// write header
retval = hw->container->writeHeader();
VS_TUT_ENSURE("could not write header", retval >= 0);
while (h->container->readNextPacket(packet.value()) == 0)
{
ic = h->coders[packet->getStreamIndex()];
oc = hw->coders[packet->getStreamIndex()];
if (packet->getStreamIndex() == h->first_input_audio_stream)
{
int offset = 0;
numPackets++;
while (offset < packet->getSize())
{
retval = ic->decodeAudio(
samples.value(),
packet.value(),
offset);
VS_TUT_ENSURE("could not decode any audio",
retval > 0);
offset += retval;
VS_TUT_ENSURE("could not write any samples",
samples->getNumSamples() > 0);
numSamples += samples->getNumSamples();
// now, write out the packets.
unsigned int numSamplesConsumed = 0;
do {
retval = oc->encodeAudio(opacket.value(), samples.value(),
numSamplesConsumed);
VS_TUT_ENSURE("Could not encode any audio", retval > 0);
numSamplesConsumed += retval;
if (opacket->isComplete())
{
VS_TUT_ENSURE("audio duration not set", opacket->getDuration() > 0);
VS_TUT_ENSURE("could not encode audio", opacket->getSize() > 0);
RefPointer<IBuffer> encodedBuffer = opacket->getData();
VS_TUT_ENSURE("no encoded data", encodedBuffer);
VS_TUT_ENSURE("less data than there should be",
encodedBuffer->getBufferSize() >=
opacket->getSize());
retval = hw->container->writePacket(opacket.value());
VS_TUT_ENSURE("could not write packet", retval >= 0);
}
} while (numSamplesConsumed < samples->getNumSamples());
}
} else if (packet->getStreamIndex() == h->first_input_video_stream)
{
int offset = 0;
numPackets++;
VS_LOG_TRACE("packet: pts: %ld; dts: %ld", packet->getPts(),
packet->getDts());
while (offset < packet->getSize())
{
retval = ic->decodeVideo(
frame.value(),
packet.value(),
offset);
VS_TUT_ENSURE("could not decode any video", retval>0);
num = ic->getTimeBase();
VS_TUT_ENSURE_DISTANCE("time base changed", num->getDouble(), h->expected_time_base, 0.0001);
offset += retval;
if (frame->isComplete())
{
VS_TUT_ENSURE("should now have a frame width", frame->getWidth() > 0);
VS_TUT_ENSURE("should now have a frame height", frame->getHeight() > 0);
numFrames++;
if (frame->isKeyFrame())
numKeyFrames++;
frame->setQuality(0);
retval = oc->encodeVideo(
opacket.value(),
frame.value(),
-1);
VS_TUT_ENSURE("could not encode video", retval >= 0);
VS_TUT_ENSURE("could not encode video", opacket->isComplete());
VS_TUT_ENSURE("could not encode video", opacket->getSize() > 0);
RefPointer<IBuffer> encodedBuffer = opacket->getData();
VS_TUT_ENSURE("no encoded data", encodedBuffer);
VS_TUT_ENSURE("less data than there should be",
encodedBuffer->getBufferSize() >=
opacket->getSize());
// now, write the packet to disk.
retval = hw->container->writePacket(opacket.value());
VS_TUT_ENSURE("could not write packet", retval >= 0);
}
}
}
}
// sigh; it turns out that to flush the encoding buffers you need to
// ask the encoder to encode a NULL set of samples. So, let's do that.
retval = hw->coders[hw->first_output_audio_stream]->encodeAudio(opacket.value(), 0, 0);
VS_TUT_ENSURE("Could not encode any audio", retval >= 0);
if (opacket->isComplete())
{
retval = hw->container->writePacket(opacket.value());
VS_TUT_ENSURE("could not write packet", retval >= 0);
}
retval = hw->coders[hw->first_output_video_stream]->encodeVideo(opacket.value(), 0, 0);
VS_TUT_ENSURE("Could not encode any video", retval >= 0);
if (opacket->isComplete())
{
retval = hw->container->writePacket(opacket.value());
VS_TUT_ENSURE("could not write packet", retval >= 0);
}
retval = hw->container->writeTrailer();
VS_TUT_ENSURE("! writeTrailer", retval >= 0);
retval = h->coders[h->first_input_audio_stream]->close();
VS_TUT_ENSURE("! close", retval >= 0);
retval = h->coders[h->first_input_video_stream]->close();
VS_TUT_ENSURE("! close", retval >= 0);
retval = hw->coders[hw->first_output_audio_stream]->close();
VS_TUT_ENSURE("! close", retval >= 0);
retval = hw->coders[hw->first_output_video_stream]->close();
VS_TUT_ENSURE("! close", retval >= 0);
VS_TUT_ENSURE("could not get any audio packets", numPackets > 0);
VS_TUT_ENSURE("could not decode any audio", numSamples > 0);
VS_TUT_ENSURE("could not decode any video", numFrames >0);
VS_TUT_ENSURE("could not find any key frames", numKeyFrames >0);
if (h->expected_packets)
VS_TUT_ENSURE_EQUALS("unexpected number of packets",
numPackets, h->expected_packets);
if (h->expected_audio_samples)
VS_TUT_ENSURE_EQUALS("unexpected number of audio samples",
numSamples, h->expected_audio_samples);
if (h->expected_video_frames)
VS_TUT_ENSURE_EQUALS("unexpected number of video frames",
numFrames, h->expected_video_frames);
if (h->expected_video_key_frames)
VS_TUT_ENSURE_EQUALS("unexpected number of video key frames",
numKeyFrames, h->expected_video_key_frames);
}