Merge pull request #5 from WinampDesktop/community

Merge to main

1 files changed, 261 insertions, 0 deletions

diff --git a/Src/external_dependencies/libmp4v2/atom_avcC.cpp b/Src/external_dependencies/libmp4v2/atom_avcC.cpp
new file mode 100644
index 00000000..f62368ce
--- /dev/null
+++ b/Src/external_dependencies/libmp4v2/atom_avcC.cpp
@@ -0,0 +1,261 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is MPEG4IP.
+ * 
+ * The Initial Developer of the Original Code is Cisco Systems Inc.
+ * Portions created by Cisco Systems Inc. are
+ * Copyright (C) Cisco Systems Inc. 2004.  All Rights Reserved.
+ * 
+ * Contributor(s): 
+ *		Bill May wmay@cisco.com
+ */
+
+#include "mp4common.h"
+
+/*
+ * SizeTableProperty is a special version of the MP4TableProperty - 
+ * the BytesProperty will need to set the value before it can read
+ * from the file
+ */
+class SizeTableProperty : public MP4TableProperty 
+{
+ public:
+  SizeTableProperty(char *name, MP4IntegerProperty *pCountProperty) :
+    MP4TableProperty(name, pCountProperty) {};
+ protected:
+  void ReadEntry(MP4File *pFile, u_int32_t index) {
+    // Each table has a size, followed by the length field
+    // first, read the length
+    m_pProperties[0]->Read(pFile, index);
+    MP4IntegerProperty *pIntProp = (MP4IntegerProperty *)m_pProperties[0];
+    // set the size in the bytes property
+    MP4BytesProperty *pBytesProp = (MP4BytesProperty *)m_pProperties[1];
+    pBytesProp->SetValueSize(pIntProp->GetValue(index), index);
+    // And read the bytes
+    m_pProperties[1]->Read(pFile, index);
+  };
+};
+
+MP4AvcCAtom::MP4AvcCAtom() 
+	: MP4Atom("avcC")
+{
+  MP4BitfieldProperty *pCount;
+  MP4TableProperty *pTable;
+
+  AddProperty( new MP4Integer8Property("configurationVersion")); /* 0 */
+
+  AddProperty( new MP4Integer8Property("AVCProfileIndication")); /* 1 */
+
+  AddProperty( new MP4Integer8Property("profile_compatibility")); /* 2 */
+
+  AddProperty( new MP4Integer8Property("AVCLevelIndication")); /* 3 */
+
+  AddProperty( new MP4BitfieldProperty("reserved", 6)); /* 4 */
+  AddProperty( new MP4BitfieldProperty("lengthSizeMinusOne", 2)); /* 5 */
+  AddProperty( new MP4BitfieldProperty("reserved1", 3)); /* 6 */
+  pCount = new MP4BitfieldProperty("numOfSequenceParameterSets", 5);
+  AddProperty(pCount); /* 7 */
+
+  pTable = new SizeTableProperty("sequenceEntries", pCount);
+  AddProperty(pTable); /* 8 */
+  pTable->AddProperty(new MP4Integer16Property("sequenceParameterSetLength"));
+  pTable->AddProperty(new MP4BytesProperty("sequenceParameterSetNALUnit"));
+
+  MP4Integer8Property *pCount2 = new MP4Integer8Property("numOfPictureParameterSets");
+  AddProperty(pCount2); /* 9 */
+
+  pTable = new SizeTableProperty("pictureEntries", pCount2);
+  AddProperty(pTable); /* 10 */
+  pTable->AddProperty(new MP4Integer16Property("pictureParameterSetLength"));
+  pTable->AddProperty(new MP4BytesProperty("pictureParameterSetNALUnit"));
+}
+
+void MP4AvcCAtom::Generate()
+{
+	MP4Atom::Generate();
+
+	((MP4Integer8Property*)m_pProperties[0])->SetValue(1);
+
+	m_pProperties[4]->SetReadOnly(false);
+	((MP4BitfieldProperty*)m_pProperties[4])->SetValue(0x3f);
+	m_pProperties[4]->SetReadOnly(true);
+
+	m_pProperties[6]->SetReadOnly(false);
+	((MP4BitfieldProperty*)m_pProperties[6])->SetValue(0x7);
+	m_pProperties[6]->SetReadOnly(true);
+#if 0
+	// property reserved4 has non-zero fixed values
+	static u_int8_t reserved4[4] = {
+		0x00, 0x18, 0xFF, 0xFF, 
+	};
+	m_pProperties[7]->SetReadOnly(false);
+	((MP4BytesProperty*)m_pProperties[7])->
+		SetValue(reserved4, sizeof(reserved4));
+	m_pProperties[7]->SetReadOnly(true);
+#endif
+}
+
+// 
+// Clone - clone my properties to destination atom
+//
+// this method simplifies duplicating avcC atom properties from 
+// source to destination file using a single API rather than 
+// having to copy each property.  This API encapsulates the object 
+// so the application layer need not concern with each property 
+// thereby isolating any future changes to atom properties.
+//
+// ----------------------------------------
+// property   description
+// ----------------------------------------
+//  
+// 0 	configurationVersion
+// 1 	AVCProfileIndication
+// 2	profile_compatibility
+// 3	AVCLevelIndication
+// 4 	reserved
+// 5 	lengthSizeMinusOne 
+// 6 	reserved
+// 7 	number of SPS
+// 8	SPS entries
+// 9	number of PPS
+// 10	PPS entries
+//
+//
+void MP4AvcCAtom::Clone(MP4AvcCAtom *dstAtom)
+{
+
+	MP4Property *dstProperty;
+  	MP4TableProperty *pTable;
+	u_int16_t i16;
+	u_int64_t i32;
+	u_int64_t i64;
+	u_int8_t *tmp;
+
+	// source pointer Property I16
+	MP4Integer16Property *spPI16;
+	// source pointer Property Bytes
+	MP4BytesProperty *spPB;
+
+	// dest pointer Property I16
+	MP4Integer16Property *dpPI16;
+	// dest pointer Property Bytes
+	MP4BytesProperty *dpPB;
+
+
+	// start with defaults and reserved fields
+	dstAtom->Generate();
+
+	// 0, 4, 6 are now generated from defaults
+	// leaving 1, 2, 3, 5, 7, 8, 9, 10 to export
+	
+	dstProperty=dstAtom->GetProperty(1);
+	((MP4Integer8Property *)dstProperty)->SetValue(
+		((MP4Integer8Property *)m_pProperties[1])->GetValue());
+	
+	dstProperty=dstAtom->GetProperty(2);
+	((MP4Integer8Property *)dstProperty)->SetValue(
+		((MP4Integer8Property *)m_pProperties[2])->GetValue());
+	
+	dstProperty=dstAtom->GetProperty(3);
+	((MP4Integer8Property *)dstProperty)->SetValue(
+		((MP4Integer8Property *)m_pProperties[3])->GetValue());
+	
+	dstProperty=dstAtom->GetProperty(5);
+	((MP4BitfieldProperty *)dstProperty)->SetValue(
+		((MP4BitfieldProperty *)m_pProperties[5])->GetValue());
+
+	// 
+	// 7 and 8 are related SPS (one set of sequence parameters) 
+	//
+	// first the count bitfield 
+	//
+	dstProperty=dstAtom->GetProperty(7);
+	dstProperty->SetReadOnly(false);
+	((MP4BitfieldProperty *)dstProperty)->SetValue(
+		((MP4BitfieldProperty *)m_pProperties[7])->GetValue());
+	dstProperty->SetReadOnly(true);
+
+	// next export SPS Length and NAL bytes */
+
+	// first source pointers
+	pTable = (MP4TableProperty *) m_pProperties[8];
+	spPI16 = (MP4Integer16Property *)pTable->GetProperty(0);
+	spPB = (MP4BytesProperty *)pTable->GetProperty(1);
+
+	// now dest pointers
+	dstProperty=dstAtom->GetProperty(8);
+	pTable = (MP4TableProperty *) dstProperty;
+	dpPI16 = (MP4Integer16Property *)pTable->GetProperty(0);
+	dpPB = (MP4BytesProperty *)pTable->GetProperty(1);
+	
+	// sps length
+	i16 = spPI16->GetValue();
+	i64 = i16;
+	// FIXME - this leaves m_maxNumElements =2
+	// but src atom m_maxNumElements is 1 
+	dpPI16->InsertValue(i64, 0);
+
+	// export byte array
+	i32 = i16;
+	// copy bytes to local buffer 
+	tmp = (u_int8_t *)MP4Malloc(i32);
+	ASSERT(tmp != NULL);
+	spPB->CopyValue(tmp, 0);	
+	// set element count
+	dpPB->SetCount(1);
+	// copy bytes 
+	dpPB->SetValue(tmp, i32, 0);
+	MP4Free((void *)tmp);
+
+	// 
+	// 9 and 10 are related PPS (one set of picture parameters) 
+	//
+	// first the integer8 count
+	//
+	dstProperty=dstAtom->GetProperty(9);
+	dstProperty->SetReadOnly(false);
+	((MP4Integer8Property *)dstProperty)->SetValue(
+		((MP4Integer8Property *)m_pProperties[9])->GetValue());
+	dstProperty->SetReadOnly(true);
+
+	// next export PPS Length and NAL bytes */
+
+	// first source pointers
+	pTable = (MP4TableProperty *) m_pProperties[10];
+	spPI16 = (MP4Integer16Property *)pTable->GetProperty(0);
+	spPB = (MP4BytesProperty *)pTable->GetProperty(1);
+
+	// now dest pointers
+	dstProperty=dstAtom->GetProperty(10);
+	pTable = (MP4TableProperty *) dstProperty;
+	dpPI16 = (MP4Integer16Property *)pTable->GetProperty(0);
+	dpPB = (MP4BytesProperty *)pTable->GetProperty(1);
+	
+	// pps length
+	i16 = spPI16->GetValue();
+	i64 = i16;
+	dpPI16->InsertValue(i64, 0);
+
+	// export byte array
+	i32 = i16;
+	// copy bytes to local buffer 
+	tmp = (u_int8_t *)MP4Malloc(i32);
+	ASSERT(tmp != NULL);
+	spPB->CopyValue(tmp, 0);	
+	// set element count
+	dpPB->SetCount(1);
+	// copy bytes 
+	dpPB->SetValue(tmp, i32, 0);
+	MP4Free((void *)tmp);
+}
+
+