本文整理汇总了C++中AP4_Sample::GetSize方法的典型用法代码示例。如果您正苦于以下问题:C++ AP4_Sample::GetSize方法的具体用法?C++ AP4_Sample::GetSize怎么用?C++ AP4_Sample::GetSize使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类AP4_Sample
的用法示例。
在下文中一共展示了AP4_Sample::GetSize方法的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1:
/*----------------------------------------------------------------------
| AP4_MarlinIpmpTrackDecrypter:GetProcessedSampleSize
+---------------------------------------------------------------------*/
AP4_Size
AP4_MarlinIpmpTrackDecrypter::GetProcessedSampleSize(AP4_Sample& sample)
{
// with CBC, we need to decrypt the last block to know what the padding was
AP4_Size encrypted_size = sample.GetSize()-AP4_AES_BLOCK_SIZE;
AP4_DataBuffer encrypted;
AP4_DataBuffer decrypted;
AP4_Size decrypted_size = AP4_CIPHER_BLOCK_SIZE;
if (sample.GetSize() < 2*AP4_CIPHER_BLOCK_SIZE) {
return 0;
}
AP4_Size offset = sample.GetSize()-2*AP4_CIPHER_BLOCK_SIZE;
if (AP4_FAILED(sample.ReadData(encrypted, 2*AP4_CIPHER_BLOCK_SIZE, offset))) {
return 0;
}
decrypted.Reserve(decrypted_size);
m_Cipher->SetIV(encrypted.GetData());
if (AP4_FAILED(m_Cipher->ProcessBuffer(encrypted.GetData()+AP4_CIPHER_BLOCK_SIZE,
AP4_CIPHER_BLOCK_SIZE,
decrypted.UseData(),
&decrypted_size,
true))) {
return 0;
}
unsigned int padding_size = AP4_CIPHER_BLOCK_SIZE-decrypted_size;
return encrypted_size-padding_size;
}
示例2:
/*----------------------------------------------------------------------
| AP4_OmaDcfCbcSampleEncrypter::GetEncryptedSampleSize
+---------------------------------------------------------------------*/
AP4_Size
AP4_OmaDcfCbcSampleEncrypter::GetEncryptedSampleSize(AP4_Sample& sample)
{
AP4_Size sample_size = sample.GetSize();
AP4_Size padding_size = AP4_CIPHER_BLOCK_SIZE-(sample_size%AP4_CIPHER_BLOCK_SIZE);
return sample_size+padding_size+AP4_CIPHER_BLOCK_SIZE+1;
}
示例3: assert
/*----------------------------------------------------------------------
| AP4_LinearReader::PopSample
+---------------------------------------------------------------------*/
bool
AP4_LinearReader::PopSample(Tracker* tracker,
AP4_Sample& sample,
AP4_DataBuffer& sample_data)
{
SampleBuffer* head = NULL;
if (AP4_SUCCEEDED(tracker->m_Samples.PopHead(head))) {
assert(head->m_Sample);
sample = *head->m_Sample;
sample_data.SetData(head->m_Data.GetData(), head->m_Data.GetDataSize());
assert(m_BufferFullness >= sample.GetSize());
m_BufferFullness -= sample.GetSize();
delete head;
return true;
}
return false;
}
示例4:
/*----------------------------------------------------------------------
| AP4_IsmaTrackDecrypter::GetProcessedSampleSize
+---------------------------------------------------------------------*/
AP4_Size
AP4_IsmaTrackDecrypter::GetProcessedSampleSize(AP4_Sample& sample)
{
AP4_Size isma_header_size =
m_CipherParams->GetKeyIndicatorLength() +
m_CipherParams->GetIvLength();
if (m_CipherParams->GetSelectiveEncryption()) {
isma_header_size++;
}
return sample.GetSize()-isma_header_size;
}
示例5: GetSampleDescription
/*----------------------------------------------------------------------
| AP4_Track::Clone
+---------------------------------------------------------------------*/
AP4_Track*
AP4_Track::Clone(AP4_Result* result)
{
AP4_SyntheticSampleTable* sample_table = new AP4_SyntheticSampleTable();
// default return value
if (result) *result = AP4_SUCCESS;
// add clones of the sample descriptions to the new sample table
for (unsigned int i=0; ;i++) {
AP4_SampleDescription* sample_description = GetSampleDescription(i);
if (sample_description == NULL) break;
sample_table->AddSampleDescription(sample_description->Clone());
}
AP4_Sample sample;
AP4_Ordinal index = 0;
while (AP4_SUCCEEDED(GetSample(index, sample))) {
AP4_ByteStream* data_stream;
data_stream = sample.GetDataStream();
sample_table->AddSample(*data_stream,
sample.GetOffset(),
sample.GetSize(),
sample.GetDuration(),
sample.GetDescriptionIndex(),
sample.GetDts(),
sample.GetCtsDelta(),
sample.IsSync());
AP4_RELEASE(data_stream); // release our ref, the table has kept its own ref.
index++;
}
// create the cloned track
AP4_Track* clone = new AP4_Track(GetType(),
sample_table,
GetId(),
GetMovieTimeScale(),
GetDuration(),
GetMediaTimeScale(),
GetMediaDuration(),
GetTrackLanguage(),
GetWidth(),
GetHeight());
return clone;
}
示例6: printf
/*----------------------------------------------------------------------
| ShowSample
+---------------------------------------------------------------------*/
static void
ShowSample(AP4_Sample& sample, unsigned int index, AP4_SampleDecrypter* sample_decrypter)
{
printf("[%06d] size=%6d duration=%6d",
index,
(int)sample.GetSize(),
(int)sample.GetDuration());
printf(" offset=%10lld dts=%10lld cts=%10lld ",
sample.GetOffset(),
sample.GetDts(),
sample.GetCts());
if (sample.IsSync()) {
printf(" [S] ");
} else {
printf(" ");
}
AP4_DataBuffer sample_data;
sample.ReadData(sample_data);
AP4_DataBuffer* data = &sample_data;
AP4_DataBuffer decrypted_sample_data;
if (sample_decrypter) {
sample_decrypter->DecryptSampleData(sample_data, decrypted_sample_data);
data = & decrypted_sample_data;
}
unsigned int show = data->GetDataSize();
if (show > 12) show = 12; // max first 12 chars
for (unsigned int i=0; i<show; i++) {
printf("%02x", data->GetData()[i]);
}
if (show == data->GetDataSize()) {
printf("\n");
} else {
printf("...\n");
}
}
示例7:
/*----------------------------------------------------------------------
| AP4_Processor::TrackHandler::GetProcessedSampleSize
+---------------------------------------------------------------------*/
AP4_Size
AP4_Processor::TrackHandler::GetProcessedSampleSize(AP4_Sample& sample)
{
// default implementation: do no change the sample size
return sample.GetSize();
}
示例8: GetSampleCount
/*----------------------------------------------------------------------
| AP4_SampleTable::GenerateStblAtom
+---------------------------------------------------------------------*/
AP4_Result
AP4_SampleTable::GenerateStblAtom(AP4_ContainerAtom*& stbl)
{
// create the stbl container
stbl = new AP4_ContainerAtom(AP4_ATOM_TYPE_STBL);
// create the stsd atom
AP4_StsdAtom* stsd = new AP4_StsdAtom(this);
// create the stsz atom
AP4_StszAtom* stsz = new AP4_StszAtom();
// create the stsc atom
AP4_StscAtom* stsc = new AP4_StscAtom();
// create the stts atom
AP4_SttsAtom* stts = new AP4_SttsAtom();
// create the stss atom
AP4_StssAtom* stss = new AP4_StssAtom();
// declare the ctts atom (may be created later)
AP4_CttsAtom* ctts = NULL;
// start chunk table
AP4_Ordinal current_chunk_index = 0;
AP4_Size current_chunk_size = 0;
AP4_Position current_chunk_offset = 0;
AP4_Cardinal current_samples_in_chunk = 0;
AP4_Ordinal current_sample_description_index = 0;
AP4_UI32 current_duration = 0;
AP4_Cardinal current_duration_run = 0;
AP4_UI32 current_cts_delta = 0;
AP4_Cardinal current_cts_delta_run = 0;
AP4_Array<AP4_Position> chunk_offsets;
// process all the samples
bool all_samples_are_sync = false;
AP4_Cardinal sample_count = GetSampleCount();
for (AP4_Ordinal i=0; i<sample_count; i++) {
AP4_Sample sample;
GetSample(i, sample);
// update DTS table
AP4_UI32 new_duration = sample.GetDuration();
if (new_duration != current_duration && current_duration_run != 0) {
// emit a new stts entry
stts->AddEntry(current_duration_run, current_duration);
// reset the run count
current_duration_run = 0;
}
++current_duration_run;
current_duration = new_duration;
// update CTS table
AP4_UI32 new_cts_delta = sample.GetCtsDelta();
if (new_cts_delta != current_cts_delta && current_cts_delta_run != 0) {
// create a ctts atom if we don't have one
if (ctts == NULL) ctts = new AP4_CttsAtom();
//emit a new ctts entry
ctts->AddEntry(current_cts_delta_run, current_cts_delta);
// reset the run count
current_cts_delta_run = 0;
}
++current_cts_delta_run;
current_cts_delta = new_cts_delta;
// add an entry into the stsz atom
stsz->AddEntry(sample.GetSize());
// update the sync sample table
if (sample.IsSync()) {
stss->AddEntry(i+1);
if (i==0) all_samples_are_sync = true;
} else {
all_samples_are_sync = false;
}
// see in which chunk this sample is
AP4_Ordinal chunk_index = 0;
AP4_Ordinal position_in_chunk = 0;
AP4_Result result = GetSampleChunkPosition(i, chunk_index, position_in_chunk);
if (AP4_SUCCEEDED(result)) {
if (chunk_index != current_chunk_index && current_samples_in_chunk != 0) {
// new chunk
chunk_offsets.Append(current_chunk_offset);
current_chunk_offset += current_chunk_size;
stsc->AddEntry(1,
current_samples_in_chunk,
current_sample_description_index+1);
current_samples_in_chunk = 0;
current_chunk_size = 0;
//.........这里部分代码省略.........
示例9: CreateFragmentHandler
/*----------------------------------------------------------------------
| AP4_Processor::ProcessFragments
+---------------------------------------------------------------------*/
AP4_Result
AP4_Processor::ProcessFragments(AP4_MoovAtom* moov,
AP4_List<AP4_MoofLocator>& moofs,
AP4_ContainerAtom* mfra,
AP4_ByteStream& input,
AP4_ByteStream& output)
{
// FIXME: this only works for non-changing moofs
for (AP4_List<AP4_MoofLocator>::Item* item = moofs.FirstItem();
item;
item = item->GetNext()) {
AP4_MoofLocator* locator = item->GetData();
AP4_ContainerAtom* moof = locator->m_Moof;
AP4_UI64 moof_offset = locator->m_Offset;
AP4_UI64 mdat_payload_offset = moof_offset+moof->GetSize()+8;
AP4_MovieFragment* fragment = new AP4_MovieFragment(moof);
AP4_Sample sample;
AP4_DataBuffer sample_data_in;
AP4_DataBuffer sample_data_out;
AP4_Result result;
// process all the traf atoms
AP4_Array<AP4_Processor::FragmentHandler*> handlers;
for (;AP4_Atom* atom = moof->GetChild(AP4_ATOM_TYPE_TRAF, handlers.ItemCount());) {
AP4_ContainerAtom* traf = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);
AP4_Processor::FragmentHandler* handler = CreateFragmentHandler(traf);
if (handler) result = handler->ProcessFragment();
handlers.Append(handler);
}
// write the moof
AP4_UI64 moof_out_start = 0;
output.Tell(moof_out_start);
bool moof_has_changed = false;
moof->Write(output);
// process all track runs
for (unsigned int i=0; i<handlers.ItemCount(); i++) {
AP4_FragmentSampleTable* sample_table = NULL;
AP4_Processor::FragmentHandler* handler = handlers[i];
// get the track ID
AP4_ContainerAtom* traf = AP4_DYNAMIC_CAST(AP4_ContainerAtom, moof->GetChild(AP4_ATOM_TYPE_TRAF, i));
AP4_TfhdAtom* tfhd = AP4_DYNAMIC_CAST(AP4_TfhdAtom, traf->GetChild(AP4_ATOM_TYPE_TFHD, i));
// create a sample table object so we can read the sample data
result = fragment->CreateSampleTable(moov, tfhd->GetTrackId(), &input, moof_offset, mdat_payload_offset, sample_table);
if (AP4_FAILED(result)) return result;
// compute the mdat size
AP4_UI64 mdat_size = 0;
for (unsigned int j=0; j<sample_table->GetSampleCount(); j++) {
result = sample_table->GetSample(j, sample);
if (AP4_FAILED(result)) return result;
mdat_size += sample.GetSize();
}
// write an mdat header
if (mdat_size > 0xFFFFFFFF-8) {
// we don't support large mdat fragments
return AP4_ERROR_OUT_OF_RANGE;
}
if (mdat_size) {
output.WriteUI32((AP4_UI32)(8+mdat_size));
output.WriteUI32(AP4_ATOM_TYPE_MDAT);
}
#if defined(AP4_DEBUG)
AP4_Position before;
output.Tell(before);
#endif
// write the mdat
for (unsigned int j=0; j<sample_table->GetSampleCount(); j++) {
result = sample_table->GetSample(j, sample);
if (AP4_FAILED(result)) return result;
sample.ReadData(sample_data_in);
// process the sample data
if (handler) {
result = handler->ProcessSample(sample_data_in, sample_data_out);
if (AP4_FAILED(result)) return result;
// write the sample data
result = output.Write(sample_data_out.GetData(), sample_data_out.GetDataSize());
if (AP4_FAILED(result)) return result;
// give the handler a chance to update the atoms
result = handler->FinishFragment();
if (AP4_SUCCEEDED(result)) moof_has_changed = true;
} else {
// write the sample data (unmodified)
result = output.Write(sample_data_in.GetData(), sample_data_in.GetDataSize());
if (AP4_FAILED(result)) return result;
}
}
//.........这里部分代码省略.........
示例10: GetSampleCount
/*----------------------------------------------------------------------
| AP4_SampleTable::GenerateStblAtom
+---------------------------------------------------------------------*/
AP4_Result
AP4_SampleTable::GenerateStblAtom(AP4_ContainerAtom*& stbl)
{
// create the stbl container
stbl = DNew AP4_ContainerAtom(AP4_ATOM_TYPE_STBL);
// create the stsd atom
AP4_StsdAtom* stsd = DNew AP4_StsdAtom(this);
// create the stsz atom
AP4_StszAtom* stsz = DNew AP4_StszAtom();
// create the stsc atom
AP4_StscAtom* stsc = DNew AP4_StscAtom();
// start chunk table
AP4_Cardinal samples_in_chunk = 0;
AP4_Offset current_chunk_offset = 0;
AP4_Size current_chunk_size = 0;
AP4_Array<AP4_UI32> chunk_offsets;
// process all the samples
AP4_Cardinal sample_count = GetSampleCount();
for (AP4_Ordinal i=0; i<sample_count; i++) {
AP4_Sample sample;
GetSample(i, sample);
// add an entry into the stsz atom
stsz->AddEntry(sample.GetSize());
// adjust the current chunk info
current_chunk_size += sample.GetSize();
// count the sample
samples_in_chunk++;
if (samples_in_chunk == 10) {
// new chunk
chunk_offsets.Append(current_chunk_offset);
stsc->AddEntry(1, 10, 1);
samples_in_chunk = 0;
// adjust the chunk offset
current_chunk_offset += current_chunk_size;
current_chunk_size = 0;
}
}
// process any unfinished chunk
if (samples_in_chunk != 0) {
// new chunk
chunk_offsets.Append(current_chunk_offset);
stsc->AddEntry(1, samples_in_chunk, 1);
}
// create the stco atom
AP4_StcoAtom* stco = DNew AP4_StcoAtom(&chunk_offsets[0],
chunk_offsets.ItemCount());
// create the stts atom (for now, we assume sample of equal duration)
AP4_SttsAtom* stts = DNew AP4_SttsAtom();
stts->AddEntry(sample_count, 1000); // FIXME
// attach the children of stbl
stbl->AddChild(stsd);
stbl->AddChild(stsz);
stbl->AddChild(stsc);
stbl->AddChild(stco);
stbl->AddChild(stts);
return AP4_SUCCESS;
}