开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mp4property.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：20k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mp4property.cpp：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  */
  22. #include "mp4common.h"
  24. MP4Property::MP4Property(const char* name)
  25. {
  26. m_name = name;
  27. m_pParentAtom = NULL;
  28. m_readOnly = false;
  29. m_implicit = false;
  30. }
  32. bool MP4Property::FindProperty(const char* name, 
  33. MP4Property** ppProperty, u_int32_t* pIndex) 
  34. {
  35. if (name == NULL) {
  36. return false;
  37. }
  39. if (!strcasecmp(m_name, name)) {
  40. if (m_pParentAtom) {
  41. VERBOSE_FIND(m_pParentAtom->GetFile()->GetVerbosity(),
  42. printf("FindProperty: matched %sn", name));
  43. }
  45. *ppProperty = this;
  46. return true;
  47. }
  48. return false;
  49. }
  51. // Integer Property
  53. u_int64_t MP4IntegerProperty::GetValue(u_int32_t index)
  54. {
  55. switch (this->GetType()) {
  56. case Integer8Property:
  57. return ((MP4Integer8Property*)this)->GetValue(index);
  58. case Integer16Property:
  59. return ((MP4Integer16Property*)this)->GetValue(index);
  60. case Integer24Property:
  61. return ((MP4Integer24Property*)this)->GetValue(index);
  62. case Integer32Property:
  63. return ((MP4Integer32Property*)this)->GetValue(index);
  64. case Integer64Property:
  65. return ((MP4Integer64Property*)this)->GetValue(index);
  66. default:
  67. ASSERT(FALSE);
  68. }
  69. return (0);
  70. }
  72. void MP4IntegerProperty::SetValue(u_int64_t value, u_int32_t index)
  73. {
  74. switch (this->GetType()) {
  75. case Integer8Property:
  76. ((MP4Integer8Property*)this)->SetValue(value, index);
  77. break;
  78. case Integer16Property:
  79. ((MP4Integer16Property*)this)->SetValue(value, index);
  80. break;
  81. case Integer24Property:
  82. ((MP4Integer24Property*)this)->SetValue(value, index);
  83. break;
  84. case Integer32Property:
  85. ((MP4Integer32Property*)this)->SetValue(value, index);
  86. break;
  87. case Integer64Property:
  88. ((MP4Integer64Property*)this)->SetValue(value, index);
  89. break;
  90. default:
  91. ASSERT(FALSE);
  92. }
  93. }
  95. void MP4IntegerProperty::InsertValue(u_int64_t value, u_int32_t index)
  96. {
  97. switch (this->GetType()) {
  98. case Integer8Property:
  99. ((MP4Integer8Property*)this)->InsertValue(value, index);
  100. break;
  101. case Integer16Property:
  102. ((MP4Integer16Property*)this)->InsertValue(value, index);
  103. break;
  104. case Integer24Property:
  105. ((MP4Integer24Property*)this)->InsertValue(value, index);
  106. break;
  107. case Integer32Property:
  108. ((MP4Integer32Property*)this)->InsertValue(value, index);
  109. break;
  110. case Integer64Property:
  111. ((MP4Integer64Property*)this)->InsertValue(value, index);
  112. break;
  113. default:
  114. ASSERT(FALSE);
  115. }
  116. }
  118. void MP4IntegerProperty::DeleteValue(u_int32_t index)
  119. {
  120. switch (this->GetType()) {
  121. case Integer8Property:
  122. ((MP4Integer8Property*)this)->DeleteValue(index);
  123. break;
  124. case Integer16Property:
  125. ((MP4Integer16Property*)this)->DeleteValue(index);
  126. break;
  127. case Integer24Property:
  128. ((MP4Integer24Property*)this)->DeleteValue(index);
  129. break;
  130. case Integer32Property:
  131. ((MP4Integer32Property*)this)->DeleteValue(index);
  132. break;
  133. case Integer64Property:
  134. ((MP4Integer64Property*)this)->DeleteValue(index);
  135. break;
  136. default:
  137. ASSERT(FALSE);
  138. }
  139. }
  141. void MP4IntegerProperty::IncrementValue(int32_t increment, u_int32_t index)
  142. {
  143. SetValue(GetValue() + increment);
  144. }
  146. void MP4Integer8Property::Dump(FILE* pFile, u_int8_t indent,
  147. bool dumpImplicits, u_int32_t index)
  148. {
  149. if (m_implicit && !dumpImplicits) {
  150. return;
  151. }
  152. Indent(pFile, indent);
  153. fprintf(pFile, "%s = %u (0x%02x)n", 
  154. m_name, m_values[index], m_values[index]);
  155. }
  157. void MP4Integer16Property::Dump(FILE* pFile, u_int8_t indent,
  158. bool dumpImplicits, u_int32_t index)
  159. {
  160. if (m_implicit && !dumpImplicits) {
  161. return;
  162. }
  163. Indent(pFile, indent);
  164. fprintf(pFile, "%s = %u (0x%04x)n", 
  165. m_name, m_values[index], m_values[index]);
  166. }
  168. void MP4Integer24Property::Dump(FILE* pFile, u_int8_t indent,
  169. bool dumpImplicits, u_int32_t index)
  170. {
  171. if (m_implicit && !dumpImplicits) {
  172. return;
  173. }
  174. Indent(pFile, indent);
  175. fprintf(pFile, "%s = %u (0x%06x)n", 
  176. m_name, m_values[index], m_values[index]);
  177. }
  179. void MP4Integer32Property::Dump(FILE* pFile, u_int8_t indent,
  180. bool dumpImplicits, u_int32_t index)
  181. {
  182. if (m_implicit && !dumpImplicits) {
  183. return;
  184. }
  185. Indent(pFile, indent);
  186. fprintf(pFile, "%s = %u (0x%08x)n", 
  187. m_name, m_values[index], m_values[index]);
  188. }
  190. void MP4Integer64Property::Dump(FILE* pFile, u_int8_t indent,
  191. bool dumpImplicits, u_int32_t index)
  192. {
  193. if (m_implicit && !dumpImplicits) {
  194. return;
  195. }
  196. Indent(pFile, indent);
  197. fprintf(pFile, 
  198. #ifdef WIN32
  199. "%s = "LLU" (0x%016I64x)n", 
  200. #else
  201. "%s = "LLU" (0x%016llx)n", 
  202. #endif
  203. m_name, m_values[index], m_values[index]);
  204. }
  206. // MP4BitfieldProperty
  208. void MP4BitfieldProperty::Read(MP4File* pFile, u_int32_t index)
  209. {
  210. if (m_implicit) {
  211. return;
  212. }
  213. m_values[index] = pFile->ReadBits(m_numBits);
  214. }
  216. void MP4BitfieldProperty::Write(MP4File* pFile, u_int32_t index)
  217. {
  218. if (m_implicit) {
  219. return;
  220. }
  221. pFile->WriteBits(m_values[index], m_numBits);
  222. }
  224. void MP4BitfieldProperty::Dump(FILE* pFile, u_int8_t indent,
  225. bool dumpImplicits, u_int32_t index)
  226. {
  227. if (m_implicit && !dumpImplicits) {
  228. return;
  229. }
  230. Indent(pFile, indent);
  232. u_int8_t hexWidth = m_numBits / 4;
  233. if (hexWidth == 0 || (m_numBits % 4)) {
  234. hexWidth++;
  235. }
  236. fprintf(pFile, 
  237. #ifdef WIN32
  238. "%s = "LLU" (0x%0*I64x) <%u bits>n", 
  239. #else
  240. "%s = "LLU" (0x%0*llx) <%u bits>n", 
  241. #endif
  242. m_name, m_values[index], (int)hexWidth, m_values[index], m_numBits);
  243. }
  245. // MP4Float32Property
  247. void MP4Float32Property::Read(MP4File* pFile, u_int32_t index) 
  248. {
  249. if (m_implicit) {
  250. return;
  251. }
  252. if (m_useFixed16Format) {
  253. m_values[index] = pFile->ReadFixed16();
  254. } else if (m_useFixed32Format) {
  255. m_values[index] = pFile->ReadFixed32();
  256. } else {
  257. m_values[index] = pFile->ReadFloat();
  258. }
  259. }
  261. void MP4Float32Property::Write(MP4File* pFile, u_int32_t index) 
  262. {
  263. if (m_implicit) {
  264. return;
  265. }
  266. if (m_useFixed16Format) {
  267. pFile->WriteFixed16(m_values[index]);
  268. } else if (m_useFixed32Format) {
  269. pFile->WriteFixed32(m_values[index]);
  270. } else {
  271. pFile->WriteFloat(m_values[index]);
  272. }
  273. }
  275. void MP4Float32Property::Dump(FILE* pFile, u_int8_t indent,
  276. bool dumpImplicits, u_int32_t index)
  277. {
  278. if (m_implicit && !dumpImplicits) {
  279. return;
  280. }
  281. Indent(pFile, indent);
  282. fprintf(pFile, "%s = %fn", 
  283. m_name, m_values[index]);
  284. }
  286. // MP4StringProperty
  288. MP4StringProperty::MP4StringProperty(char* name, 
  289. bool useCountedFormat, bool useUnicode)
  290. : MP4Property(name)
  291. {
  292. SetCount(1);
  293. m_values[0] = NULL;
  294. m_useCountedFormat = useCountedFormat;
  295. m_useExpandedCount = false;
  296. m_useUnicode = useUnicode;
  297. m_fixedLength = 0; // length not fixed
  298. }
  300. MP4StringProperty::~MP4StringProperty() 
  301. {
  302. u_int32_t count = GetCount();
  303. for (u_int32_t i = 0; i < count; i++) {
  304. MP4Free(m_values[i]);
  305. }
  306. }
  308. void MP4StringProperty::SetCount(u_int32_t count) 
  309. {
  310. u_int32_t oldCount = m_values.Size();
  312. m_values.Resize(count);
  314. for (u_int32_t i = oldCount; i < count; i++) {
  315. m_values[i] = NULL;
  316. }
  317. }
  319. void MP4StringProperty::SetValue(const char* value, u_int32_t index) 
  320. {
  321. if (m_readOnly) {
  322. throw new MP4Error(EACCES, "property is read-only", m_name);
  323. }
  325. MP4Free(m_values[index]);
  327. if (m_fixedLength) {
  328. m_values[index] = (char*)MP4Calloc(m_fixedLength + 1);
  329. if (value) {
  330. strncpy(m_values[index], value, m_fixedLength);
  331. }
  332. } else {
  333. if (value) {
  334. m_values[index] = MP4Stralloc(value);
  335. } else {
  336. m_values[index] = NULL;
  337. }
  338. }
  339. }
  341. void MP4StringProperty::Read(MP4File* pFile, u_int32_t index)
  342. {
  343. if (m_implicit) {
  344. return;
  345. }
  346. if (m_useCountedFormat) {
  347. m_values[index] = pFile->ReadCountedString(
  348. (m_useUnicode ? 2 : 1), m_useExpandedCount);
  349. } else if (m_fixedLength) {
  350. MP4Free(m_values[index]);
  351. m_values[index] = (char*)MP4Calloc(m_fixedLength + 1);
  352. pFile->ReadBytes((u_int8_t*)m_values[index], m_fixedLength);
  353. } else {
  354. m_values[index] = pFile->ReadString();
  355. }
  356. }
  358. void MP4StringProperty::Write(MP4File* pFile, u_int32_t index)
  359. {
  360. if (m_implicit) {
  361. return;
  362. }
  363. if (m_useCountedFormat) {
  364. pFile->WriteCountedString(m_values[index],
  365. (m_useUnicode ? 2 : 1), m_useExpandedCount);
  366. } else if (m_fixedLength) {
  367. pFile->WriteBytes((u_int8_t*)m_values[index], m_fixedLength);
  368. } else {
  369. pFile->WriteString(m_values[index]);
  370. }
  371. }
  373. void MP4StringProperty::Dump(FILE* pFile, u_int8_t indent,
  374. bool dumpImplicits, u_int32_t index)
  375. {
  376. if (m_implicit && !dumpImplicits) {
  377. return;
  378. }
  379. Indent(pFile, indent);
  380. if (m_useUnicode) {
  381. fprintf(pFile, "%s = %lsn", m_name, (wchar_t*)m_values[index]);
  382. } else {
  383. fprintf(pFile, "%s = %sn", m_name, m_values[index]);
  384. }
  385. }
  387. // MP4BytesProperty
  389. MP4BytesProperty::MP4BytesProperty(char* name, u_int32_t valueSize)
  390. : MP4Property(name)
  391. {
  392. SetCount(1);
  393. m_values[0] = (u_int8_t*)MP4Calloc(valueSize);
  394. m_valueSizes[0] = valueSize;
  395. m_fixedValueSize = 0;
  396. }
  398. MP4BytesProperty::~MP4BytesProperty() 
  399. {
  400. u_int32_t count = GetCount();
  401. for (u_int32_t i = 0; i < count; i++) {
  402. MP4Free(m_values[i]);
  403. }
  404. }
  405.   
  406. void MP4BytesProperty::SetCount(u_int32_t count) 
  407. {
  408. u_int32_t oldCount = m_values.Size();
  410. m_values.Resize(count);
  411. m_valueSizes.Resize(count);
  413. for (u_int32_t i = oldCount; i < count; i++) {
  414. m_values[i] = NULL;
  415. m_valueSizes[i] = 0;
  416. }
  417. }
  419. void MP4BytesProperty::SetValue(const u_int8_t* pValue, u_int32_t valueSize, 
  420. u_int32_t index) 
  421. {
  422. if (m_readOnly) {
  423. throw new MP4Error(EACCES, "property is read-only", m_name);
  424. }
  425. if (m_fixedValueSize) {
  426. if (valueSize > m_fixedValueSize) {
  427. throw new MP4Error("value size exceeds fixed value size",
  428. "MP4BytesProperty::SetValue");
  429. }
  430. if (m_values[index] == NULL) {
  431. m_values[index] = (u_int8_t*)MP4Calloc(m_fixedValueSize);
  432. m_valueSizes[index] = m_fixedValueSize;
  433. }
  434. if (pValue) {
  435. memcpy(m_values[index], pValue, valueSize);
  436. }
  437. } else {
  438. MP4Free(m_values[index]);
  439. if (pValue) {
  440. m_values[index] = (u_int8_t*)MP4Malloc(valueSize);
  441. memcpy(m_values[index], pValue, valueSize);
  442. m_valueSizes[index] = valueSize;
  443. } else {
  444. m_values[index] = NULL;
  445. m_valueSizes[index] = 0;
  446. }
  447. }
  448. }
  450. void MP4BytesProperty::SetValueSize(u_int32_t valueSize, u_int32_t index) 
  451. {
  452. if (m_fixedValueSize) {
  453. throw new MP4Error("can't change size of fixed sized property",
  454. "MP4BytesProperty::SetValueSize");
  455. }
  456. if (m_values[index] != NULL) {
  457. m_values[index] = (u_int8_t*)MP4Realloc(m_values[index], valueSize);
  458. }
  459. m_valueSizes[index] = valueSize;
  460. }
  462. void MP4BytesProperty::SetFixedSize(u_int32_t fixedSize) 
  463. {
  464. m_fixedValueSize = 0;
  465. for (u_int32_t i = 0; i < GetCount(); i++) {
  466. SetValueSize(fixedSize, i);
  467. }
  468. m_fixedValueSize = fixedSize;
  469. }
  471. void MP4BytesProperty::Read(MP4File* pFile, u_int32_t index)
  472. {
  473. if (m_implicit) {
  474. return;
  475. }
  476. MP4Free(m_values[index]);
  477. m_values[index] = (u_int8_t*)MP4Malloc(m_valueSizes[index]);
  478. pFile->ReadBytes(m_values[index], m_valueSizes[index]);
  479. }
  481. void MP4BytesProperty::Write(MP4File* pFile, u_int32_t index)
  482. {
  483. if (m_implicit) {
  484. return;
  485. }
  486. pFile->WriteBytes(m_values[index], m_valueSizes[index]);
  487. }
  489. void MP4BytesProperty::Dump(FILE* pFile, u_int8_t indent,
  490. bool dumpImplicits, u_int32_t index)
  491. {
  492. if (m_implicit && !dumpImplicits) {
  493. return;
  494. }
  495. Indent(pFile, indent);
  496. fprintf(pFile, "%s = <%u bytes> ", m_name, m_valueSizes[index]);
  497. for (u_int32_t i = 0; i < m_valueSizes[index]; i++) {
  498. if ((i % 16) == 0 && m_valueSizes[index] > 16) {
  499. fprintf(pFile, "n");
  500. Indent(pFile, indent);
  501. }
  502. fprintf(pFile, "%02x ", m_values[index][i]);
  503. }
  504. fprintf(pFile, "n");
  505. }
  507. // MP4TableProperty
  509. MP4TableProperty::MP4TableProperty(char* name, MP4Property* pCountProperty)
  510. : MP4Property(name) 
  511. {
  512. ASSERT(pCountProperty->GetType() == Integer8Property
  513. || pCountProperty->GetType() == Integer32Property);
  514. m_pCountProperty = pCountProperty;
  515. m_pCountProperty->SetReadOnly();
  516. }
  518. MP4TableProperty::~MP4TableProperty()
  519. {
  520. for (u_int32_t i = 0; i < m_pProperties.Size(); i++) {
  521. delete m_pProperties[i];
  522. }
  523. }
  525. void MP4TableProperty::AddProperty(MP4Property* pProperty) 
  526. {
  527. ASSERT(pProperty);
  528. ASSERT(pProperty->GetType() != TableProperty);
  529. ASSERT(pProperty->GetType() != DescriptorProperty);
  530. m_pProperties.Add(pProperty);
  531. pProperty->SetParentAtom(m_pParentAtom);
  532. pProperty->SetCount(0);
  533. }
  535. bool MP4TableProperty::FindProperty(const char *name,
  536. MP4Property** ppProperty, u_int32_t* pIndex)
  537. {
  538. ASSERT(m_name);
  540. // check if first component of name matches ourselves
  541. if (!MP4NameFirstMatches(m_name, name)) {
  542. return false;
  543. }
  545. // check if the specified table entry exists
  546. u_int32_t index;
  547. bool haveIndex = MP4NameFirstIndex(name, &index);
  548. if (haveIndex) {
  549. if (index >= GetCount()) {
  550. return false;
  551. }
  552. if (pIndex) {
  553. *pIndex = index;
  554. }
  555. }
  557. VERBOSE_FIND(m_pParentAtom->GetFile()->GetVerbosity(),
  558. printf("FindProperty: matched %sn", name));
  560. // get name of table property
  561. const char *tablePropName = MP4NameAfterFirst(name);
  562. if (tablePropName == NULL) {
  563. if (!haveIndex) {
  564. *ppProperty = this;
  565. return true;
  566. }
  567. return false;
  568. }
  570. // check if this table property exists
  571. return FindContainedProperty(tablePropName, ppProperty, pIndex);
  572. }
  574. bool MP4TableProperty::FindContainedProperty(const char *name,
  575. MP4Property** ppProperty, u_int32_t* pIndex)
  576. {
  577. u_int32_t numProperties = m_pProperties.Size();
  579. for (u_int32_t i = 0; i < numProperties; i++) {
  580. if (m_pProperties[i]->FindProperty(name, ppProperty, pIndex)) {
  581. return true;
  582. }
  583. }
  584. return false;
  585. }
  587. void MP4TableProperty::Read(MP4File* pFile, u_int32_t index)
  588. {
  589. ASSERT(index == 0);
  591. if (m_implicit) {
  592. return;
  593. }
  595. u_int32_t numProperties = m_pProperties.Size();
  597. if (numProperties == 0) {
  598. WARNING(numProperties == 0);
  599. return;
  600. }
  602. u_int32_t numEntries = GetCount();
  604. /* for each property set size */
  605. for (u_int32_t j = 0; j < numProperties; j++) {
  606. m_pProperties[j]->SetCount(numEntries);
  607. }
  609. for (u_int32_t i = 0; i < numEntries; i++) {
  610. ReadEntry(pFile, i);
  611. }
  612. }
  614. void MP4TableProperty::ReadEntry(MP4File* pFile, u_int32_t index)
  615. {
  616. for (u_int32_t j = 0; j < m_pProperties.Size(); j++) {
  617. m_pProperties[j]->Read(pFile, index);
  618. }
  619. }
  621. void MP4TableProperty::Write(MP4File* pFile, u_int32_t index)
  622. {
  623. ASSERT(index == 0);
  625. if (m_implicit) {
  626. return;
  627. }
  629. u_int32_t numProperties = m_pProperties.Size();
  631. if (numProperties == 0) {
  632. WARNING(numProperties == 0);
  633. return;
  634. }
  636. u_int32_t numEntries = GetCount();
  638. ASSERT(m_pProperties[0]->GetCount() == numEntries);
  640. for (u_int32_t i = 0; i < numEntries; i++) {
  641. WriteEntry(pFile, i);
  642. }
  643. }
  645. void MP4TableProperty::WriteEntry(MP4File* pFile, u_int32_t index)
  646. {
  647. for (u_int32_t j = 0; j < m_pProperties.Size(); j++) {
  648. m_pProperties[j]->Write(pFile, index);
  649. }
  650. }
  652. void MP4TableProperty::Dump(FILE* pFile, u_int8_t indent,
  653. bool dumpImplicits, u_int32_t index)
  654. {
  655. ASSERT(index == 0);
  657. // implicit tables just can't be dumped
  658. if (m_implicit) {
  659. return;
  660. }
  662. u_int32_t numProperties = m_pProperties.Size();
  664. if (numProperties == 0) {
  665. WARNING(numProperties == 0);
  666. return;
  667. }
  669. u_int32_t numEntries = GetCount();
  671. for (u_int32_t i = 0; i < numEntries; i++) {
  672. for (u_int32_t j = 0; j < numProperties; j++) {
  673. m_pProperties[j]->Dump(pFile, indent + 1, dumpImplicits, i);
  674. }
  675. }
  676. }
  678. // MP4DescriptorProperty
  679.   
  680. MP4DescriptorProperty::MP4DescriptorProperty(char* name, 
  681. u_int8_t tagsStart, u_int8_t tagsEnd, bool mandatory, bool onlyOne)
  682. : MP4Property(name) 
  683. { 
  684. SetTags(tagsStart, tagsEnd);
  685. m_sizeLimit = 0;
  686. m_mandatory = mandatory;
  687. m_onlyOne = onlyOne;
  688. }
  690. MP4DescriptorProperty::~MP4DescriptorProperty() 
  691. {
  692. for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
  693. delete m_pDescriptors[i];
  694. }
  695. }
  697. void MP4DescriptorProperty::SetParentAtom(MP4Atom* pParentAtom) {
  698. m_pParentAtom = pParentAtom;
  699. for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
  700. m_pDescriptors[i]->SetParentAtom(pParentAtom);
  701. }
  702. }
  704. MP4Descriptor* MP4DescriptorProperty::AddDescriptor(u_int8_t tag)
  705. {
  706. // check that tag is in expected range
  707. ASSERT(tag >= m_tagsStart && tag <= m_tagsEnd);
  709. MP4Descriptor* pDescriptor = CreateDescriptor(tag);
  710. ASSERT(pDescriptor);
  712. m_pDescriptors.Add(pDescriptor);
  713. pDescriptor->SetParentAtom(m_pParentAtom);
  715. return pDescriptor;
  716. }
  718. void MP4DescriptorProperty::DeleteDescriptor(u_int32_t index)
  719. {
  720. delete m_pDescriptors[index];
  721. m_pDescriptors.Delete(index);
  722. }
  724. void MP4DescriptorProperty::Generate()
  725. {
  726. // generate a default descriptor
  727. // if it is mandatory, and single
  728. if (m_mandatory && m_onlyOne) {
  729. MP4Descriptor* pDescriptor = 
  730. AddDescriptor(m_tagsStart);
  731. pDescriptor->Generate();
  732. }
  733. }
  735. bool MP4DescriptorProperty::FindProperty(const char *name,
  736. MP4Property** ppProperty, u_int32_t* pIndex)
  737. {
  738. // we're unnamed, so just check contained properties
  739. if (m_name == NULL || !strcmp(m_name, "")) {
  740. return FindContainedProperty(name, ppProperty, pIndex);
  741. }
  743. // check if first component of name matches ourselves
  744. if (!MP4NameFirstMatches(m_name, name)) {
  745. return false;
  746. }
  748. // check if the specific descriptor entry exists
  749. u_int32_t descrIndex;
  750. bool haveDescrIndex = MP4NameFirstIndex(name, &descrIndex);
  752. if (haveDescrIndex && descrIndex >= GetCount()) {
  753. return false;
  754. }
  756. if (m_pParentAtom) {
  757. VERBOSE_FIND(m_pParentAtom->GetFile()->GetVerbosity(),
  758. printf("FindProperty: matched %sn", name));
  759. }
  761. // get name of descriptor property
  762. name = MP4NameAfterFirst(name);
  763. if (name == NULL) {
  764. if (!haveDescrIndex) {
  765. *ppProperty = this;
  766. return true;
  767. }
  768. return false;
  769. }
  771. /* check rest of name */
  772. if (haveDescrIndex) {
  773. return m_pDescriptors[descrIndex]->FindProperty(name, 
  774. ppProperty, pIndex); 
  775. } else {
  776. return FindContainedProperty(name, ppProperty, pIndex);
  777. }
  778. }
  780. bool MP4DescriptorProperty::FindContainedProperty(const char *name,
  781. MP4Property** ppProperty, u_int32_t* pIndex)
  782. {
  783. for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
  784. if (m_pDescriptors[i]->FindProperty(name, ppProperty, pIndex)) {
  785. return true;
  786. }
  787. }
  788. return false;
  789. }
  791. void MP4DescriptorProperty::Read(MP4File* pFile, u_int32_t index)
  792. {
  793. ASSERT(index == 0);
  795. if (m_implicit) {
  796. return;
  797. }
  799. u_int64_t start = pFile->GetPosition();
  801. while (true) {
  802. // enforce size limitation
  803. if (m_sizeLimit && pFile->GetPosition() >= start + m_sizeLimit) {
  804. break;
  805. }
  807. u_int8_t tag;
  808. try {
  809. pFile->PeekBytes(&tag, 1);
  810. }
  811. catch (MP4Error* e) {
  812. if (pFile->GetPosition() >= pFile->GetSize()) {
  813. // EOF
  814. delete e;
  815. break;
  816. }
  817. throw e;
  818. }
  820. // check if tag is in desired range
  821. if (tag < m_tagsStart || tag > m_tagsEnd) {
  822. break;
  823. }
  825. MP4Descriptor* pDescriptor = 
  826. AddDescriptor(tag);
  828. pDescriptor->Read(pFile);
  829. }
  831. // warnings
  832. if (m_mandatory && m_pDescriptors.Size() == 0) {
  833. VERBOSE_READ(pFile->GetVerbosity(),
  834. printf("Warning: Mandatory descriptor 0x%02x missingn",
  835. m_tagsStart));
  836. } else if (m_onlyOne && m_pDescriptors.Size() > 1) {
  837. VERBOSE_READ(pFile->GetVerbosity(),
  838. printf("Warning: Descriptor 0x%02x has more than one instancen",
  839. m_tagsStart));
  840. }
  841. }
  843. void MP4DescriptorProperty::Write(MP4File* pFile, u_int32_t index)
  844. {
  845. ASSERT(index == 0);
  847. if (m_implicit) {
  848. return;
  849. }
  851. for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
  852. m_pDescriptors[i]->Write(pFile);
  853. }
  854. }
  856. void MP4DescriptorProperty::Dump(FILE* pFile, u_int8_t indent,
  857. bool dumpImplicits, u_int32_t index)
  858. {
  859. ASSERT(index == 0);
  861. if (m_implicit && !dumpImplicits) {
  862. return;
  863. }
  865. if (m_name) {
  866. Indent(pFile, indent);
  867. fprintf(pFile, "%sn", m_name);
  868. indent++;
  869. }
  871. for (u_int32_t i = 0; i < m_pDescriptors.Size(); i++) {
  872. m_pDescriptors[i]->Dump(pFile, indent, dumpImplicits);
  873. }
  874. }