本文整理汇总了C++中AP4_DataBuffer::GetDataSize方法的典型用法代码示例。如果您正苦于以下问题:C++ AP4_DataBuffer::GetDataSize方法的具体用法?C++ AP4_DataBuffer::GetDataSize怎么用?C++ AP4_DataBuffer::GetDataSize使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类AP4_DataBuffer
的用法示例。
在下文中一共展示了AP4_DataBuffer::GetDataSize方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1:
/*----------------------------------------------------------------------
| AP4_OmaDcfCtrSampleEncrypter::EncryptSampleData
+---------------------------------------------------------------------*/
AP4_Result
AP4_OmaDcfCtrSampleEncrypter::EncryptSampleData(AP4_DataBuffer& data_in,
AP4_DataBuffer& data_out,
AP4_UI64 counter,
bool /*skip_encryption*/)
{
// setup the buffers
const unsigned char* in = data_in.GetData();
AP4_CHECK(data_out.SetDataSize(data_in.GetDataSize()+AP4_CIPHER_BLOCK_SIZE+1));
unsigned char* out = data_out.UseData();
// selective encryption flag
*out++ = 0x80;
// IV on 16 bytes: [SSSSSSSSXXXXXXXX]
// where SSSSSSSS is the 64-bit salt and
// XXXXXXXX is the 64-bit base counter
AP4_CopyMemory(out, m_Salt, 8);
AP4_BytesFromUInt64BE(&out[8], counter);
// encrypt the payload
AP4_Size data_size = data_in.GetDataSize();
m_Cipher->SetIV(out);
m_Cipher->ProcessBuffer(in, data_size, out+AP4_CIPHER_BLOCK_SIZE);
return AP4_SUCCESS;
}
示例2:
/*----------------------------------------------------------------------
| AP4_SgpdAtom::WriteFields
+---------------------------------------------------------------------*/
AP4_Result
AP4_SgpdAtom::WriteFields(AP4_ByteStream& stream)
{
AP4_Result result;
result = stream.WriteUI32(m_GroupingType);
if (AP4_FAILED(result)) return result;
if (m_Version >= 1) {
result = stream.WriteUI32(m_DefaultLength);
if (AP4_FAILED(result)) return result;
}
// write the children
result = stream.WriteUI32(m_Entries.ItemCount());
if (AP4_FAILED(result)) return result;
for (AP4_List<AP4_DataBuffer>::Item* item = m_Entries.FirstItem();
item;
item = item->GetNext()) {
AP4_DataBuffer* entry = item->GetData();
if (m_Version >= 1) {
if (m_DefaultLength == 0) {
stream.WriteUI32((AP4_UI32)entry->GetDataSize());
}
}
result = stream.Write(entry->GetData(), entry->GetDataSize());
if (AP4_FAILED(result)) {
return result;
}
}
return AP4_SUCCESS;
}
示例3: MinHeaderSize
/*----------------------------------------------------------------------
| AP4_DecoderSpecificInfoDescriptor::AP4_DecoderSpecificInfoDescriptor
+---------------------------------------------------------------------*/
AP4_DecoderSpecificInfoDescriptor::AP4_DecoderSpecificInfoDescriptor(
const AP4_DataBuffer& data) :
AP4_Descriptor(AP4_DESCRIPTOR_TAG_DECODER_SPECIFIC_INFO,
MinHeaderSize(data.GetDataSize()),
data.GetDataSize()),
m_Info(data)
{
}
示例4: DecryptSampleData
/*----------------------------------------------------------------------
| WV_CencSingleSampleDecrypter::DecryptSampleData
+---------------------------------------------------------------------*/
AP4_Result WV_CencSingleSampleDecrypter::DecryptSampleData(
AP4_DataBuffer& data_in,
AP4_DataBuffer& data_out,
const AP4_UI08* iv,
unsigned int subsample_count,
const AP4_UI16* bytes_of_cleartext_data,
const AP4_UI32* bytes_of_encrypted_data)
{
// the output has the same size as the input
data_out.SetDataSize(data_in.GetDataSize());
if (!wv_adapter)
{
data_out.SetData(data_in.GetData(), data_in.GetDataSize());
return AP4_SUCCESS;
}
// check input parameters
if (iv == NULL) return AP4_ERROR_INVALID_PARAMETERS;
if (subsample_count) {
if (bytes_of_cleartext_data == NULL || bytes_of_encrypted_data == NULL) {
return AP4_ERROR_INVALID_PARAMETERS;
}
}
// transform ap4 format into cmd format
cdm::InputBuffer cdm_in;
if (subsample_count > max_subsample_count_)
{
subsample_buffer_ = (cdm::SubsampleEntry*)realloc(subsample_buffer_, subsample_count*sizeof(cdm::SubsampleEntry));
max_subsample_count_ = subsample_count;
}
for (cdm::SubsampleEntry *b(subsample_buffer_), *e(subsample_buffer_ + subsample_count); b != e; ++b, ++bytes_of_cleartext_data, ++bytes_of_encrypted_data)
{
b->clear_bytes = *bytes_of_cleartext_data;
b->cipher_bytes = *bytes_of_encrypted_data;
}
cdm_in.data = data_in.GetData();
cdm_in.data_size = data_in.GetDataSize();
cdm_in.iv = iv;
cdm_in.iv_size = 16; //Always 16, see AP4_CencSingleSampleDecrypter declaration.
cdm_in.key_id = wv_adapter->GetKeyId();
cdm_in.key_id_size = wv_adapter->GetKeyIdSize();
cdm_in.num_subsamples = subsample_count;
cdm_in.subsamples = subsample_buffer_;
CdmBuffer buf(&data_out);
CdmDecryptedBlock cdm_out;
cdm_out.SetDecryptedBuffer(&buf);
cdm::Status ret = wv_adapter->Decrypt(cdm_in, &cdm_out);
return (ret == cdm::Status::kSuccess) ? AP4_SUCCESS : AP4_ERROR_INVALID_PARAMETERS;
}
示例5: sizeof
/*----------------------------------------------------------------------
| AP4_SgpdAtom::InspectFields
+---------------------------------------------------------------------*/
AP4_Result
AP4_SgpdAtom::InspectFields(AP4_AtomInspector& inspector)
{
char fourcc[5];
AP4_FormatFourChars(fourcc, m_GroupingType);
inspector.AddField("grouping_type", fourcc);
if (m_Version >= 1) {
inspector.AddField("default_length", m_DefaultLength);
}
inspector.AddField("entry_count", m_Entries.ItemCount());
// inspect entries
char header[32];
unsigned int i=0;
for (AP4_List<AP4_DataBuffer>::Item* item = m_Entries.FirstItem();
item;
item = item->GetNext()) {
AP4_DataBuffer* entry = item->GetData();
AP4_FormatString(header, sizeof(header), "entry %02d", i);
++i;
inspector.AddField(header, entry->GetData(), entry->GetDataSize());
}
return AP4_SUCCESS;
}
示例6:
/*----------------------------------------------------------------------
| AP4_MarlinIpmpTrackEncrypter:ProcessSample
+---------------------------------------------------------------------*/
AP4_Result
AP4_MarlinIpmpTrackEncrypter::ProcessSample(AP4_DataBuffer& data_in,
AP4_DataBuffer& data_out)
{
AP4_Result result;
const AP4_UI08* in = data_in.GetData();
AP4_Size in_size = data_in.GetDataSize();
// default to 0 output
data_out.SetDataSize(0);
// process the sample data
AP4_Size out_size = AP4_CIPHER_BLOCK_SIZE*(2+(in_size/AP4_CIPHER_BLOCK_SIZE));
data_out.SetDataSize(out_size);
AP4_UI08* out = data_out.UseData();
// write the IV
AP4_CopyMemory(out, m_IV, AP4_CIPHER_BLOCK_SIZE);
out_size -= AP4_CIPHER_BLOCK_SIZE;
// encrypt the data
m_Cipher->SetIV(m_IV);
result = m_Cipher->ProcessBuffer(in,
in_size,
out+AP4_AES_BLOCK_SIZE,
&out_size,
true);
if (AP4_FAILED(result)) return result;
// update the payload size
data_out.SetDataSize(out_size+AP4_AES_BLOCK_SIZE);
return AP4_SUCCESS;
}
示例7:
/*----------------------------------------------------------------------
| AP4_UnknownSampleEntry::AP4_UnknownSampleEntry
+---------------------------------------------------------------------*/
AP4_UnknownSampleEntry::AP4_UnknownSampleEntry(AP4_Atom::Type type,
AP4_DataBuffer& payload) :
AP4_SampleEntry(type),
m_Payload(payload)
{
m_Size32 += payload.GetDataSize();
}
示例8:
/*----------------------------------------------------------------------
| AP4_DefaultFragmentHandler::ProcessSample
+---------------------------------------------------------------------*/
AP4_Result
AP4_DefaultFragmentHandler::ProcessSample(AP4_DataBuffer& data_in, AP4_DataBuffer& data_out)
{
if (m_TrackHandler == NULL) {
data_out.SetData(data_in.GetData(), data_in.GetDataSize());
return AP4_SUCCESS;
}
return m_TrackHandler->ProcessSample(data_in, data_out);
}
示例9:
/*----------------------------------------------------------------------
| AP4_IsmaTrackEncrypter::ProcessSample
+---------------------------------------------------------------------*/
AP4_Result
AP4_IsmaTrackEncrypter::ProcessSample(AP4_DataBuffer& data_in,
AP4_DataBuffer& data_out)
{
AP4_Result result = m_Cipher->EncryptSample(data_in, data_out, m_ByteOffset, false);
if (AP4_FAILED(result)) return result;
m_ByteOffset += data_in.GetDataSize();
return AP4_SUCCESS;
}
示例10: while
/*----------------------------------------------------------------------
| AP4_IsmaCipher::DecryptSample
+---------------------------------------------------------------------*/
AP4_Result
AP4_IsmaCipher::DecryptSample(AP4_DataBuffer& data_in,
AP4_DataBuffer& data_out)
{
bool is_encrypted = true;
const unsigned char* in = data_in.GetData();
if (m_SelectiveEncryption) {
is_encrypted = ((in[0]&1)==1);
in++;
}
// get the IV (this implementation only supports un to 32 bits of IV)
// so we skip anything beyond the last 4 bytes
unsigned int to_read = m_IvLength;
if (to_read > 16 || to_read == 0) return AP4_ERROR_INVALID_FORMAT;
while (to_read > 4) {
to_read--;
in++;
}
AP4_UI32 iv = 0;
while (to_read--) {
iv = (iv<<8) | *in++;
}
// get the key indicator (we only support up to 32 bits as well)
to_read = m_KeyIndicatorLength;
if (to_read > 4 ) return AP4_ERROR_INVALID_FORMAT;
while (to_read > 4) {
to_read--;
in++;
}
AP4_UI32 key_indicator = 0;
while (to_read--) {
key_indicator = (key_indicator<<8) | *in++;
}
// we only support key indicator = 0 for now... (TODO)
if (key_indicator != 0) {
return AP4_FAILURE;
}
// process the sample data
unsigned int header_size = in-data_in.GetData();
unsigned int payload_size = data_in.GetDataSize()-header_size;
data_out.SetDataSize(payload_size);
unsigned char* out = data_out.UseData();
if (is_encrypted) {
m_Cipher->SetStreamOffset(iv);
m_Cipher->ProcessBuffer(in, out, payload_size);
} else {
memcpy(out, in, payload_size);
}
return AP4_SUCCESS;
}
示例11: fprintf
/*----------------------------------------------------------------------
| MakeFramePrefix
+---------------------------------------------------------------------*/
static AP4_Result
MakeFramePrefix(AP4_SampleDescription* sdesc, AP4_DataBuffer& prefix, unsigned int& nalu_length_size)
{
AP4_AvcSampleDescription* avc_desc = AP4_DYNAMIC_CAST(AP4_AvcSampleDescription, sdesc);
if (avc_desc == NULL) {
fprintf(stderr, "ERROR: track does not contain an AVC stream\n");
return AP4_FAILURE;
}
if (sdesc->GetFormat() == AP4_SAMPLE_FORMAT_AVC3 || sdesc->GetFormat() == AP4_SAMPLE_FORMAT_AVC4) {
// no need for a prefix, SPS/PPS NALs should be in the elementary stream already
return AP4_SUCCESS;
}
// make the SPS/PPS prefix
nalu_length_size = avc_desc->GetNaluLengthSize();
for (unsigned int i=0; i<avc_desc->GetSequenceParameters().ItemCount(); i++) {
AP4_DataBuffer& buffer = avc_desc->GetSequenceParameters()[i];
unsigned int prefix_size = prefix.GetDataSize();
prefix.SetDataSize(prefix_size+4+buffer.GetDataSize());
unsigned char* p = prefix.UseData()+prefix_size;
*p++ = 0;
*p++ = 0;
*p++ = 0;
*p++ = 1;
AP4_CopyMemory(p, buffer.GetData(), buffer.GetDataSize());
}
for (unsigned int i=0; i<avc_desc->GetPictureParameters().ItemCount(); i++) {
AP4_DataBuffer& buffer = avc_desc->GetPictureParameters()[i];
unsigned int prefix_size = prefix.GetDataSize();
prefix.SetDataSize(prefix_size+4+buffer.GetDataSize());
unsigned char* p = prefix.UseData()+prefix_size;
*p++ = 0;
*p++ = 0;
*p++ = 0;
*p++ = 1;
AP4_CopyMemory(p, buffer.GetData(), buffer.GetDataSize());
}
return AP4_SUCCESS;
}
示例12: 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");
}
}
示例13: UpdatePPSId
virtual void UpdatePPSId(AP4_DataBuffer const &buffer) override
{
//Search the Slice header NALU
const AP4_UI08 *data(buffer.GetData());
unsigned int data_size(buffer.GetDataSize());
for (; data_size;)
{
// sanity check
if (data_size < naluLengthSize)
break;
// get the next NAL unit
AP4_UI32 nalu_size;
switch (naluLengthSize) {
case 1:nalu_size = *data++; data_size--; break;
case 2:nalu_size = AP4_BytesToInt16BE(data); data += 2; data_size -= 2; break;
case 4:nalu_size = AP4_BytesToInt32BE(data); data += 4; data_size -= 4; break;
default: data_size = 0; nalu_size = 1; break;
}
if (nalu_size > data_size)
break;
// Stop further NALU processing
if (countPictureSetIds < 2)
naluLengthSize = 0;
unsigned int nal_unit_type = *data & 0x1F;
if (
//nal_unit_type == AP4_AVC_NAL_UNIT_TYPE_CODED_SLICE_OF_NON_IDR_PICTURE ||
nal_unit_type == AP4_AVC_NAL_UNIT_TYPE_CODED_SLICE_OF_IDR_PICTURE //||
//nal_unit_type == AP4_AVC_NAL_UNIT_TYPE_CODED_SLICE_DATA_PARTITION_A ||
//nal_unit_type == AP4_AVC_NAL_UNIT_TYPE_CODED_SLICE_DATA_PARTITION_B ||
//nal_unit_type == AP4_AVC_NAL_UNIT_TYPE_CODED_SLICE_DATA_PARTITION_C
) {
AP4_DataBuffer unescaped(data, data_size);
AP4_NalParser::Unescape(unescaped);
AP4_BitReader bits(unescaped.GetData(), unescaped.GetDataSize());
bits.SkipBits(8); // NAL Unit Type
AP4_AvcFrameParser::ReadGolomb(bits); // first_mb_in_slice
AP4_AvcFrameParser::ReadGolomb(bits); // slice_type
pictureId = AP4_AvcFrameParser::ReadGolomb(bits); //picture_set_id
}
// move to the next NAL unit
data += nalu_size;
data_size -= nalu_size;
}
}
示例14: while
/*----------------------------------------------------------------------
| WriteSample
+---------------------------------------------------------------------*/
static void
WriteSample(const AP4_DataBuffer& sample_data,
AP4_DataBuffer& prefix,
unsigned int nalu_length_size,
AP4_ByteStream* output)
{
const unsigned char* data = sample_data.GetData();
unsigned int data_size = sample_data.GetDataSize();
// detect if we have VPS/SPS/PPS and/or AUD NAL units already
bool have_param_sets = false;
bool have_access_unit_delimiter = false;
while (data_size) {
// sanity check
if (data_size < nalu_length_size) break;
// get the next NAL unit
AP4_UI32 nalu_size;
if (nalu_length_size == 1) {
nalu_size = *data++;
data_size--;
} else if (nalu_length_size == 2) {
nalu_size = AP4_BytesToInt16BE(data);
data += 2;
data_size -= 2;
} else if (nalu_length_size == 4) {
nalu_size = AP4_BytesToInt32BE(data);
data += 4;
data_size -= 4;
} else {
break;
}
if (nalu_size > data_size) break;
unsigned int nal_unit_type = (data[0]>>1)&0x3F;
if (nal_unit_type == AP4_HEVC_NALU_TYPE_AUD_NUT) {
have_access_unit_delimiter = true;
}
if (nal_unit_type == AP4_HEVC_NALU_TYPE_VPS_NUT ||
nal_unit_type == AP4_HEVC_NALU_TYPE_SPS_NUT ||
nal_unit_type == AP4_HEVC_NALU_TYPE_PPS_NUT) {
have_param_sets = true;
break;
}
// move to the next NAL unit
data += nalu_size;
data_size -= nalu_size;
}
data = sample_data.GetData();
data_size = sample_data.GetDataSize();
// allocate a buffer for the frame data
AP4_DataBuffer frame_data;
unsigned char* frame_buffer = NULL;
// add a delimiter if we don't already have one
if (data_size && !have_access_unit_delimiter) {
AP4_Size frame_data_size = frame_data.GetDataSize();
frame_data.SetDataSize(frame_data_size+7);
frame_buffer = frame_data.UseData()+frame_data_size;
// start of access unit
frame_buffer[0] = 0;
frame_buffer[1] = 0;
frame_buffer[2] = 0;
frame_buffer[3] = 1;
frame_buffer[4] = AP4_HEVC_NALU_TYPE_AUD_NUT<<1;
frame_buffer[5] = 1;
frame_buffer[6] = 0x40; // pic_type = 2 (B,P,I)
}
// write the NAL units
bool prefix_added = false;
while (data_size) {
// sanity check
if (data_size < nalu_length_size) break;
// get the next NAL unit
AP4_UI32 nalu_size;
if (nalu_length_size == 1) {
nalu_size = *data++;
data_size--;
} else if (nalu_length_size == 2) {
nalu_size = AP4_BytesToInt16BE(data);
data += 2;
data_size -= 2;
} else if (nalu_length_size == 4) {
nalu_size = AP4_BytesToInt32BE(data);
data += 4;
data_size -= 4;
} else {
break;
}
if (nalu_size > data_size) break;
// add the prefix if needed
//.........这里部分代码省略.........
示例15: fprintf
/*----------------------------------------------------------------------
| MakeFramePrefix
+---------------------------------------------------------------------*/
static AP4_Result
MakeFramePrefix(AP4_SampleDescription* sdesc, AP4_DataBuffer& prefix, unsigned int& nalu_length_size)
{
AP4_HevcSampleDescription* hevc_desc = AP4_DYNAMIC_CAST(AP4_HevcSampleDescription, sdesc);
if (hevc_desc == NULL) {
fprintf(stderr, "ERROR: track does not contain an HEVC stream\n");
return AP4_FAILURE;
}
// extract the nalu length size
nalu_length_size = hevc_desc->GetNaluLengthSize();
// make the VPS/SPS/PPS prefix
for (unsigned int i=0; i<hevc_desc->GetSequences().ItemCount(); i++) {
const AP4_HvccAtom::Sequence& seq = hevc_desc->GetSequences()[i];
if (seq.m_NaluType == AP4_HEVC_NALU_TYPE_VPS_NUT) {
for (unsigned int j=0; j<seq.m_Nalus.ItemCount(); j++) {
const AP4_DataBuffer& buffer = seq.m_Nalus[j];
unsigned int prefix_size = prefix.GetDataSize();
prefix.SetDataSize(prefix_size+4+buffer.GetDataSize());
unsigned char* p = prefix.UseData()+prefix_size;
*p++ = 0;
*p++ = 0;
*p++ = 0;
*p++ = 1;
AP4_CopyMemory(p, buffer.GetData(), buffer.GetDataSize());
}
}
}
for (unsigned int i=0; i<hevc_desc->GetSequences().ItemCount(); i++) {
const AP4_HvccAtom::Sequence& seq = hevc_desc->GetSequences()[i];
if (seq.m_NaluType == AP4_HEVC_NALU_TYPE_SPS_NUT) {
for (unsigned int j=0; j<seq.m_Nalus.ItemCount(); j++) {
const AP4_DataBuffer& buffer = seq.m_Nalus[j];
unsigned int prefix_size = prefix.GetDataSize();
prefix.SetDataSize(prefix_size+4+buffer.GetDataSize());
unsigned char* p = prefix.UseData()+prefix_size;
*p++ = 0;
*p++ = 0;
*p++ = 0;
*p++ = 1;
AP4_CopyMemory(p, buffer.GetData(), buffer.GetDataSize());
}
}
}
for (unsigned int i=0; i<hevc_desc->GetSequences().ItemCount(); i++) {
const AP4_HvccAtom::Sequence& seq = hevc_desc->GetSequences()[i];
if (seq.m_NaluType == AP4_HEVC_NALU_TYPE_PPS_NUT) {
for (unsigned int j=0; j<seq.m_Nalus.ItemCount(); j++) {
const AP4_DataBuffer& buffer = seq.m_Nalus[j];
unsigned int prefix_size = prefix.GetDataSize();
prefix.SetDataSize(prefix_size+4+buffer.GetDataSize());
unsigned char* p = prefix.UseData()+prefix_size;
*p++ = 0;
*p++ = 0;
*p++ = 0;
*p++ = 1;
AP4_CopyMemory(p, buffer.GetData(), buffer.GetDataSize());
}
}
}
return AP4_SUCCESS;
}