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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

isma.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. static u_int8_t BifsV2Config[3] = {
  25. 0x00, 0x00, 0x40 // IsCommandStream
  26. };
  28. void MP4File::MakeIsmaCompliant(bool addIsmaComplianceSdp)
  29. {
  30. ProtectWriteOperation("MP4MakeIsmaCompliant");
  32. if (m_useIsma) {
  33. // already done
  34. return;
  35. }
  36. m_useIsma = true;
  38. // find first audio and/or video tracks
  40. MP4TrackId audioTrackId = MP4_INVALID_TRACK_ID;
  41. try {
  42. audioTrackId = FindTrackId(0, MP4_AUDIO_TRACK_TYPE);
  43. }
  44. catch (MP4Error* e) {
  45. delete e;
  46. }
  48. MP4TrackId videoTrackId = MP4_INVALID_TRACK_ID;
  49. try {
  50. videoTrackId = FindTrackId(0, MP4_VIDEO_TRACK_TYPE);
  51. }
  52. catch (MP4Error* e) {
  53. delete e;
  54. }
  56. u_int64_t fileMsDuration =
  57. ConvertFromMovieDuration(GetDuration(), MP4_MSECS_TIME_SCALE);
  59. // delete any existing OD track
  60. if (m_odTrackId != MP4_INVALID_TRACK_ID) {
  61. DeleteTrack(m_odTrackId);
  62. }
  64. AddODTrack();
  65. SetODProfileLevel(0xFF);
  67. if (audioTrackId != MP4_INVALID_TRACK_ID) {
  68. AddTrackToOd(audioTrackId);
  69. }
  71. if (videoTrackId != MP4_INVALID_TRACK_ID) {
  72. AddTrackToOd(videoTrackId);
  73. }
  75. // delete any existing scene track
  76. MP4TrackId sceneTrackId = MP4_INVALID_TRACK_ID;
  77. try {
  78. sceneTrackId = FindTrackId(0, MP4_SCENE_TRACK_TYPE);
  79. }
  80. catch (MP4Error *e) {
  81. delete e;
  82. }
  83. if (sceneTrackId != MP4_INVALID_TRACK_ID) {
  84. DeleteTrack(sceneTrackId);
  85. }
  87. // add scene track
  88. sceneTrackId = AddSceneTrack();
  89. SetSceneProfileLevel(0xFF);
  90. SetGraphicsProfileLevel(0xFF);
  91. SetTrackIntegerProperty(sceneTrackId, 
  92. "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr.objectTypeId", 
  93. MP4SystemsV2ObjectType);
  95. SetTrackESConfiguration(sceneTrackId, 
  96. BifsV2Config, sizeof(BifsV2Config));
  98. u_int8_t* pBytes = NULL;
  99. u_int64_t numBytes = 0;
  101. // write OD Update Command
  102. CreateIsmaODUpdateCommandFromFileForFile(
  103. m_odTrackId, 
  104. audioTrackId, 
  105. videoTrackId,
  106. &pBytes, 
  107. &numBytes);
  109. WriteSample(m_odTrackId, pBytes, numBytes, fileMsDuration);
  111. MP4Free(pBytes);
  112. pBytes = NULL;
  114. // write BIFS Scene Replace Command
  115. CreateIsmaSceneCommand(
  116. MP4_IS_VALID_TRACK_ID(audioTrackId), 
  117. MP4_IS_VALID_TRACK_ID(videoTrackId),
  118. &pBytes, 
  119. &numBytes);
  121. WriteSample(sceneTrackId, pBytes, numBytes, fileMsDuration);
  123. MP4Free(pBytes);
  124. pBytes = NULL;
  126. // add session level sdp 
  127. CreateIsmaIodFromFile(
  128. m_odTrackId, 
  129. sceneTrackId, 
  130. audioTrackId, 
  131. videoTrackId,
  132. &pBytes, 
  133. &numBytes);
  135. char* iodBase64 = MP4ToBase64(pBytes, numBytes);
  137. char* sdpBuf = (char*)MP4Calloc(strlen(iodBase64) + 256);
  139. if (addIsmaComplianceSdp) {
  140. strcpy(sdpBuf, "a=isma-compliance:1,1.0,11512");
  141. }
  143. sprintf(&sdpBuf[strlen(sdpBuf)], 
  144. "a=mpeg4-iod: 42data:application/mpeg4-iod;base64,%s421512",
  145. iodBase64);
  147. SetSessionSdp(sdpBuf);
  149. VERBOSE_ISMA(GetVerbosity(),
  150. printf("IOD SDP = %sn", sdpBuf));
  152. MP4Free(iodBase64);
  153. iodBase64 = NULL;
  154. MP4Free(pBytes);
  155. pBytes = NULL;
  156. MP4Free(sdpBuf);
  157. sdpBuf = NULL;
  158. }
  160. static void CloneIntegerProperty(
  161. MP4Descriptor* pDest, 
  162. MP4DescriptorProperty* pSrc,
  163. const char* name)
  164. {
  165. MP4IntegerProperty* pGetProperty;
  166. MP4IntegerProperty* pSetProperty;
  168. pSrc->FindProperty(name, (MP4Property**)&pGetProperty);
  169. pDest->FindProperty(name, (MP4Property**)&pSetProperty);
  171. pSetProperty->SetValue(pGetProperty->GetValue());
  172. } 
  174. void MP4File::CreateIsmaIodFromFile(
  175. MP4TrackId odTrackId,
  176. MP4TrackId sceneTrackId,
  177. MP4TrackId audioTrackId, 
  178. MP4TrackId videoTrackId,
  179. u_int8_t** ppBytes,
  180. u_int64_t* pNumBytes)
  181. {
  182. MP4Descriptor* pIod = new MP4IODescriptor();
  183. pIod->SetTag(MP4IODescrTag);
  184. pIod->Generate();
  186. MP4Atom* pIodsAtom = FindAtom("moov.iods");
  187. ASSERT(pIodsAtom);
  188. MP4DescriptorProperty* pSrcIod = 
  189. (MP4DescriptorProperty*)pIodsAtom->GetProperty(2);
  191. CloneIntegerProperty(pIod, pSrcIod, "objectDescriptorId");
  192. CloneIntegerProperty(pIod, pSrcIod, "ODProfileLevelId");
  193. CloneIntegerProperty(pIod, pSrcIod, "sceneProfileLevelId");
  194. CloneIntegerProperty(pIod, pSrcIod, "audioProfileLevelId");
  195. CloneIntegerProperty(pIod, pSrcIod, "visualProfileLevelId");
  196. CloneIntegerProperty(pIod, pSrcIod, "graphicsProfileLevelId");
  198. // mutate esIds from MP4ESIDIncDescrTag to MP4ESDescrTag
  199. MP4DescriptorProperty* pEsProperty;
  200. pIod->FindProperty("esIds", (MP4Property**)&pEsProperty);
  201. pEsProperty->SetTags(MP4ESDescrTag);
  203. MP4IntegerProperty* pSetProperty;
  205. // OD
  206. MP4Descriptor* pOdEsd =
  207. pEsProperty->AddDescriptor(MP4ESDescrTag);
  208. pOdEsd->Generate();
  210. pOdEsd->FindProperty("ESID", 
  211. (MP4Property**)&pSetProperty);
  212. pSetProperty->SetValue(m_odTrackId);
  214. pOdEsd->FindProperty("URLFlag", 
  215. (MP4Property**)&pSetProperty);
  216. pSetProperty->SetValue(1);
  218. u_int8_t* pBytes;
  219. u_int64_t numBytes;
  221. CreateIsmaODUpdateCommandFromFileForStream(
  222. audioTrackId, 
  223. videoTrackId,
  224. &pBytes, 
  225. &numBytes);
  227. VERBOSE_ISMA(GetVerbosity(),
  228. printf("OD data =n"); MP4HexDump(pBytes, numBytes));
  230. char* odCmdBase64 = MP4ToBase64(pBytes, numBytes);
  232. char* urlBuf = (char*)MP4Malloc(strlen(odCmdBase64) + 64);
  234. sprintf(urlBuf, 
  235. "data:application/mpeg4-od-au;base64,%s",
  236. odCmdBase64);
  238. MP4StringProperty* pUrlProperty;
  239. pOdEsd->FindProperty("URL", 
  240. (MP4Property**)&pUrlProperty);
  241. pUrlProperty->SetValue(urlBuf);
  243. VERBOSE_ISMA(GetVerbosity(),
  244. printf("OD data URL = 42%s42n", urlBuf));
  246. MP4Free(odCmdBase64);
  247. odCmdBase64 = NULL;
  248. MP4Free(pBytes);
  249. pBytes = NULL;
  250. MP4Free(urlBuf);
  251. urlBuf = NULL;
  253. MP4DescriptorProperty* pSrcDcd = NULL;
  255. // HACK temporarily point to scene decoder config
  256. FindProperty(MakeTrackName(odTrackId, 
  257. "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr"),
  258. (MP4Property**)&pSrcDcd);
  259. ASSERT(pSrcDcd);
  260. MP4Property* pOrgOdEsdProperty = 
  261. pOdEsd->GetProperty(8);
  262. pOdEsd->SetProperty(8, pSrcDcd);
  264. // bufferSizeDB needs to be set appropriately
  265. MP4BitfieldProperty* pBufferSizeProperty = NULL;
  266. pOdEsd->FindProperty("decConfigDescr.bufferSizeDB",
  267. (MP4Property**)&pBufferSizeProperty);
  268. ASSERT(pBufferSizeProperty);
  269. pBufferSizeProperty->SetValue(numBytes);
  271. // SL config needs to change from 2 (file) to 1 (null)
  272. pOdEsd->FindProperty("slConfigDescr.predefined", 
  273. (MP4Property**)&pSetProperty);
  274. pSetProperty->SetValue(1);
  277. // Scene
  278. MP4Descriptor* pSceneEsd =
  279. pEsProperty->AddDescriptor(MP4ESDescrTag);
  280. pSceneEsd->Generate();
  282. pSceneEsd->FindProperty("ESID", 
  283. (MP4Property**)&pSetProperty);
  284. pSetProperty->SetValue(sceneTrackId);
  286. pSceneEsd->FindProperty("URLFlag", 
  287. (MP4Property**)&pSetProperty);
  288. pSetProperty->SetValue(1);
  290. CreateIsmaSceneCommand(
  291. MP4_IS_VALID_TRACK_ID(audioTrackId), 
  292. MP4_IS_VALID_TRACK_ID(videoTrackId),
  293. &pBytes, 
  294. &numBytes);
  296. VERBOSE_ISMA(GetVerbosity(),
  297. printf("Scene data =n"); MP4HexDump(pBytes, numBytes));
  299. char *sceneCmdBase64 = MP4ToBase64(pBytes, numBytes);
  301. urlBuf = (char*)MP4Malloc(strlen(sceneCmdBase64) + 64);
  302. sprintf(urlBuf, 
  303. "data:application/mpeg4-bifs-au;base64,%s",
  304. sceneCmdBase64);
  306. pSceneEsd->FindProperty("URL", 
  307. (MP4Property**)&pUrlProperty);
  308. pUrlProperty->SetValue(urlBuf);
  310. VERBOSE_ISMA(GetVerbosity(),
  311. printf("Scene data URL = 42%s42n", urlBuf));
  313. MP4Free(sceneCmdBase64);
  314. sceneCmdBase64 = NULL;
  315. MP4Free(urlBuf);
  316. urlBuf = NULL;
  317. MP4Free(pBytes);
  318. pBytes = NULL;
  320. // HACK temporarily point to scene decoder config
  321. FindProperty(MakeTrackName(sceneTrackId, 
  322. "mdia.minf.stbl.stsd.mp4s.esds.decConfigDescr"),
  323. (MP4Property**)&pSrcDcd);
  324. ASSERT(pSrcDcd);
  325. MP4Property* pOrgSceneEsdProperty = 
  326. pSceneEsd->GetProperty(8);
  327. pSceneEsd->SetProperty(8, pSrcDcd);
  329. // bufferSizeDB needs to be set
  330. pBufferSizeProperty = NULL;
  331. pSceneEsd->FindProperty("decConfigDescr.bufferSizeDB",
  332. (MP4Property**)&pBufferSizeProperty);
  333. ASSERT(pBufferSizeProperty);
  334. pBufferSizeProperty->SetValue(numBytes);
  336. // SL config needs to change from 2 (file) to 1 (null)
  337. pSceneEsd->FindProperty("slConfigDescr.predefined", 
  338. (MP4Property**)&pSetProperty);
  339. pSetProperty->SetValue(1);
  342. // finally get the whole thing written to a memory 
  343. pIod->WriteToMemory(this, ppBytes, pNumBytes);
  346. // now carefully replace esd properties before destroying
  347. pOdEsd->SetProperty(8, pOrgOdEsdProperty);
  348. pSceneEsd->SetProperty(8, pOrgSceneEsdProperty);
  350. delete pIod;
  352. VERBOSE_ISMA(GetVerbosity(),
  353. printf("IOD data =n"); MP4HexDump(*ppBytes, *pNumBytes));
  354. }
  356. void MP4File::CreateIsmaIodFromParams(
  357. u_int8_t videoProfile,
  358. u_int32_t videoBitrate,
  359. u_int8_t* videoConfig,
  360. u_int32_t videoConfigLength,
  361. u_int8_t audioProfile,
  362. u_int32_t audioBitrate,
  363. u_int8_t* audioConfig,
  364. u_int32_t audioConfigLength,
  365. u_int8_t** ppIodBytes,
  366. u_int64_t* pIodNumBytes)
  367. {
  368. MP4IntegerProperty* pInt;
  369. u_int8_t* pBytes = NULL;
  370. u_int64_t numBytes;
  372. // Create the IOD
  373. MP4Descriptor* pIod = new MP4IODescriptor();
  374. pIod->SetTag(MP4IODescrTag);
  375. pIod->Generate();
  377. // Set audio and video profileLevels
  378. pIod->FindProperty("audioProfileLevelId", 
  379. (MP4Property**)&pInt);
  380. pInt->SetValue(audioProfile);
  382. pIod->FindProperty("visualProfileLevelId", 
  383. (MP4Property**)&pInt);
  384. pInt->SetValue(videoProfile);
  386. // Mutate esIds from MP4ESIDIncDescrTag to MP4ESDescrTag
  387. MP4DescriptorProperty* pEsProperty;
  388. pIod->FindProperty("esIds", (MP4Property**)&pEsProperty);
  389. pEsProperty->SetTags(MP4ESDescrTag);
  391. // Add ES Descriptors
  393. // Scene
  394. CreateIsmaSceneCommand(
  395. (audioProfile != 0xFF),
  396. (videoProfile != 0xFF),
  397. &pBytes, 
  398. &numBytes);
  400. VERBOSE_ISMA(GetVerbosity(),
  401. printf("Scene data =n"); MP4HexDump(pBytes, numBytes));
  403. char* sceneCmdBase64 = MP4ToBase64(pBytes, numBytes);
  405. char* urlBuf = 
  406. (char*)MP4Malloc(strlen(sceneCmdBase64) + 64);
  407. sprintf(urlBuf, 
  408. "data:application/mpeg4-bifs-au;base64,%s",
  409. sceneCmdBase64);
  411. VERBOSE_ISMA(GetVerbosity(),
  412. printf("Scene data URL = 42%s42n", urlBuf));
  414. MP4Descriptor* pSceneEsd =
  415. CreateESD(
  416. pEsProperty,
  417. 201, // esid
  418. MP4SystemsV2ObjectType,
  419. MP4SceneDescriptionStreamType,
  420. numBytes, // bufferSize
  421. numBytes * 8, // bitrate
  422. BifsV2Config,
  423. sizeof(BifsV2Config),
  424. urlBuf);
  426. MP4Free(sceneCmdBase64);
  427. sceneCmdBase64 = NULL;
  428. MP4Free(urlBuf);
  429. urlBuf = NULL;
  430. MP4Free(pBytes);
  431. pBytes = NULL;
  433. // Video
  434. MP4Descriptor* pVideoEsd =
  435. CreateESD(
  436. pEsProperty,
  437. 20, // esid
  438. MP4_MPEG4_VIDEO_TYPE,
  439. MP4VisualStreamType,
  440. videoBitrate / 8, // bufferSize
  441. videoBitrate,
  442. videoConfig,
  443. videoConfigLength,
  444. NULL);
  446. // Audio
  447. MP4Descriptor* pAudioEsd =
  448. CreateESD(
  449. pEsProperty,
  450. 10, // esid
  451. MP4_MPEG4_AUDIO_TYPE,
  452. MP4AudioStreamType,
  453. audioBitrate / 8,  // bufferSize
  454. audioBitrate,
  455. audioConfig,
  456. audioConfigLength,
  457. NULL);
  459. // OD
  461. // Glop to make infrastructure happy
  462. MP4DescriptorProperty* pAudioEsdProperty =
  463. new MP4DescriptorProperty();
  464. pAudioEsdProperty->AppendDescriptor(pAudioEsd);
  465. MP4DescriptorProperty* pVideoEsdProperty =
  466. new MP4DescriptorProperty();
  467. pVideoEsdProperty->AppendDescriptor(pVideoEsd);
  469. CreateIsmaODUpdateCommandForStream(
  470. pAudioEsdProperty,
  471. pVideoEsdProperty, 
  472. &pBytes,
  473. &numBytes);
  475. // TBD cleanup temporary descriptor properties
  477. VERBOSE_ISMA(GetVerbosity(),
  478. printf("OD data =n"); MP4HexDump(pBytes, numBytes));
  480. char* odCmdBase64 = MP4ToBase64(pBytes, numBytes);
  482. urlBuf = (char*)MP4Malloc(strlen(odCmdBase64) + 64);
  484. sprintf(urlBuf, 
  485. "data:application/mpeg4-od-au;base64,%s",
  486. odCmdBase64);
  488. VERBOSE_ISMA(GetVerbosity(),
  489. printf("OD data URL = 42%s42n", urlBuf));
  491. MP4Descriptor* pOdEsd =
  492. CreateESD(
  493. pEsProperty,
  494. 101,
  495. MP4SystemsV1ObjectType,
  496. MP4ObjectDescriptionStreamType,
  497. numBytes, // bufferSize
  498. numBytes * 8, // bitrate
  499. NULL, // config
  500. 0, // configLength
  501. urlBuf);
  503. MP4Free(odCmdBase64);
  504. odCmdBase64 = NULL;
  505. MP4Free(pBytes);
  506. pBytes = NULL;
  507. MP4Free(urlBuf);
  508. urlBuf = NULL;
  510. // finally get the whole thing written to a memory 
  511. pIod->WriteToMemory(this, ppIodBytes, pIodNumBytes);
  513. delete pIod;
  515. VERBOSE_ISMA(GetVerbosity(),
  516. printf("IOD data =n"); MP4HexDump(*ppIodBytes, *pIodNumBytes));
  517. }
  519. MP4Descriptor* MP4File::CreateESD(
  520. MP4DescriptorProperty* pEsProperty,
  521. u_int32_t esid,
  522. u_int8_t objectType,
  523. u_int8_t streamType,
  524. u_int32_t bufferSize,
  525. u_int32_t bitrate,
  526. u_int8_t* pConfig,
  527. u_int32_t configLength,
  528. char* url)
  529. {
  530. MP4IntegerProperty* pInt;
  531. MP4StringProperty* pString;
  532. MP4BytesProperty* pBytes;
  534. MP4Descriptor* pEsd =
  535. pEsProperty->AddDescriptor(MP4ESDescrTag);
  536. pEsd->Generate();
  538. pEsd->FindProperty("ESID", 
  539. (MP4Property**)&pInt);
  540. pInt->SetValue(esid);
  542. pEsd->FindProperty("decConfigDescr.objectTypeId", 
  543. (MP4Property**)&pInt);
  544. pInt->SetValue(objectType);
  546. pEsd->FindProperty("decConfigDescr.streamType", 
  547. (MP4Property**)&pInt);
  548. pInt->SetValue(streamType);
  550. pEsd->FindProperty("decConfigDescr.bufferSizeDB", 
  551. (MP4Property**)&pInt);
  552. pInt->SetValue(bufferSize);
  554. pEsd->FindProperty("decConfigDescr.maxBitrate", 
  555. (MP4Property**)&pInt);
  556. pInt->SetValue(bitrate);
  558. pEsd->FindProperty("decConfigDescr.avgBitrate", 
  559. (MP4Property**)&pInt);
  560. pInt->SetValue(bitrate);
  562. MP4DescriptorProperty* pConfigDescrProperty;
  563. pEsd->FindProperty("decConfigDescr.decSpecificInfo",
  564. (MP4Property**)&pConfigDescrProperty);
  566. MP4Descriptor* pConfigDescr =
  567. pConfigDescrProperty->AddDescriptor(MP4DecSpecificDescrTag);
  568. pConfigDescr->Generate();
  570. pConfigDescrProperty->FindProperty("decSpecificInfo[0].info",
  571. (MP4Property**)&pBytes);
  572. pBytes->SetValue(pConfig, configLength);
  574. pEsd->FindProperty("slConfigDescr.predefined", 
  575. (MP4Property**)&pInt);
  576. pInt->SetValue(1);
  578. if (url) {
  579. pEsd->FindProperty("URLFlag", 
  580. (MP4Property**)&pInt);
  581. pInt->SetValue(1);
  583. pEsd->FindProperty("URL", 
  584. (MP4Property**)&pString);
  585. pString->SetValue(url);
  586. }
  588. return pEsd;
  589. }
  591. void MP4File::CreateIsmaODUpdateCommandFromFileForFile(
  592. MP4TrackId odTrackId,
  593. MP4TrackId audioTrackId, 
  594. MP4TrackId videoTrackId,
  595. u_int8_t** ppBytes,
  596. u_int64_t* pNumBytes)
  597. {
  598. MP4Descriptor* pCommand = CreateODCommand(MP4ODUpdateODCommandTag);
  599. pCommand->Generate();
  601. for (u_int8_t i = 0; i < 2; i++) {
  602. MP4TrackId trackId;
  603. u_int16_t odId;
  605. if (i == 0) {
  606. trackId = audioTrackId;
  607. odId = 10;
  608. } else {
  609. trackId = videoTrackId;
  610. odId = 20;
  611. }
  613. if (trackId == MP4_INVALID_TRACK_ID) {
  614. continue;
  615. }
  617. MP4DescriptorProperty* pOdDescrProperty =
  618. (MP4DescriptorProperty*)(pCommand->GetProperty(0));
  620. pOdDescrProperty->SetTags(MP4FileODescrTag);
  622. MP4Descriptor* pOd =
  623. pOdDescrProperty->AddDescriptor(MP4FileODescrTag);
  625. pOd->Generate();
  627. MP4BitfieldProperty* pOdIdProperty = NULL;
  628. pOd->FindProperty("objectDescriptorId", 
  629. (MP4Property**)&pOdIdProperty);
  630. pOdIdProperty->SetValue(odId);
  632. MP4DescriptorProperty* pEsIdsDescriptorProperty = NULL;
  633. pOd->FindProperty("esIds", 
  634. (MP4Property**)&pEsIdsDescriptorProperty);
  635. ASSERT(pEsIdsDescriptorProperty);
  637. pEsIdsDescriptorProperty->SetTags(MP4ESIDRefDescrTag);
  639. MP4Descriptor *pRefDescriptor =
  640. pEsIdsDescriptorProperty->AddDescriptor(MP4ESIDRefDescrTag);
  641. pRefDescriptor->Generate();
  643. MP4Integer16Property* pRefIndexProperty = NULL;
  644. pRefDescriptor->FindProperty("refIndex", 
  645. (MP4Property**)&pRefIndexProperty);
  646. ASSERT(pRefIndexProperty);
  648. u_int32_t mpodIndex = FindTrackReference(
  649. MakeTrackName(odTrackId, "tref.mpod"), trackId);
  650. ASSERT(mpodIndex != 0);
  652. pRefIndexProperty->SetValue(mpodIndex);
  653. }
  655. pCommand->WriteToMemory(this, ppBytes, pNumBytes);
  657. delete pCommand;
  658. }
  660. void MP4File::CreateIsmaODUpdateCommandFromFileForStream(
  661. MP4TrackId audioTrackId, 
  662. MP4TrackId videoTrackId,
  663. u_int8_t** ppBytes,
  664. u_int64_t* pNumBytes)
  665. {
  666. MP4DescriptorProperty* pAudioEsd = NULL;
  667. MP4Integer8Property* pAudioSLConfig = NULL;
  668. MP4DescriptorProperty* pVideoEsd = NULL;
  669. MP4Integer8Property* pVideoSLConfig = NULL;
  671. if (audioTrackId != MP4_INVALID_TRACK_ID) {
  672. MP4Atom* pEsdsAtom = 
  673. FindAtom(MakeTrackName(audioTrackId, 
  674. "mdia.minf.stbl.stsd.mp4a.esds"));
  675. ASSERT(pEsdsAtom);
  677. pAudioEsd = (MP4DescriptorProperty*)(pEsdsAtom->GetProperty(2));
  679. // SL config needs to change from 2 (file) to 1 (null)
  680. pAudioEsd->FindProperty("slConfigDescr.predefined", 
  681. (MP4Property**)&pAudioSLConfig);
  682. ASSERT(pAudioSLConfig);
  683. pAudioSLConfig->SetValue(1);
  684. }
  686. if (videoTrackId != MP4_INVALID_TRACK_ID) {
  687. MP4Atom* pEsdsAtom = 
  688. FindAtom(MakeTrackName(videoTrackId, 
  689. "mdia.minf.stbl.stsd.mp4v.esds"));
  690. ASSERT(pEsdsAtom);
  692. pVideoEsd = (MP4DescriptorProperty*)(pEsdsAtom->GetProperty(2));
  694. // SL config needs to change from 2 (file) to 1 (null)
  695. pVideoEsd->FindProperty("slConfigDescr.predefined", 
  696. (MP4Property**)&pVideoSLConfig);
  697. ASSERT(pVideoSLConfig);
  698. pVideoSLConfig->SetValue(1);
  699. }
  701. CreateIsmaODUpdateCommandForStream(
  702. pAudioEsd, pVideoEsd, ppBytes, pNumBytes);
  704. // return SL config values to 2 (file)
  705. if (pAudioSLConfig) {
  706. pAudioSLConfig->SetValue(2);
  707. }
  708. if (pVideoSLConfig) {
  709. pVideoSLConfig->SetValue(2);
  710. }
  711. }
  713. void MP4File::CreateIsmaODUpdateCommandForStream(
  714. MP4DescriptorProperty* pAudioEsdProperty, 
  715. MP4DescriptorProperty* pVideoEsdProperty,
  716. u_int8_t** ppBytes,
  717. u_int64_t* pNumBytes)
  718. {
  719. MP4Descriptor* pAudioOd = NULL;
  720. MP4Descriptor* pVideoOd = NULL;
  722. MP4Descriptor* pCommand = 
  723. CreateODCommand(MP4ODUpdateODCommandTag);
  724. pCommand->Generate();
  726. for (u_int8_t i = 0; i < 2; i++) {
  727. u_int16_t odId;
  728. MP4DescriptorProperty* pEsdProperty = NULL;
  730. if (i == 0) {
  731. odId = 10;
  732. pEsdProperty = pAudioEsdProperty;
  733. } else {
  734. odId = 20;
  735. pEsdProperty = pVideoEsdProperty;
  736. }
  738. if (pEsdProperty == NULL) {
  739. continue;
  740. }
  742. MP4DescriptorProperty* pOdDescrProperty =
  743. (MP4DescriptorProperty*)(pCommand->GetProperty(0));
  745. pOdDescrProperty->SetTags(MP4ODescrTag);
  747. MP4Descriptor* pOd =
  748. pOdDescrProperty->AddDescriptor(MP4ODescrTag);
  749. pOd->Generate();
  751. if (i == 0) {
  752. pAudioOd = pOd;
  753. } else {
  754. pVideoOd = pOd;
  755. }
  757. MP4BitfieldProperty* pOdIdProperty = NULL;
  758. pOd->FindProperty("objectDescriptorId", 
  759. (MP4Property**)&pOdIdProperty);
  760. pOdIdProperty->SetValue(odId);
  762. delete (MP4DescriptorProperty*)pOd->GetProperty(4);
  763. pOd->SetProperty(4, pEsdProperty);
  764. }
  766. // serialize OD command
  767. pCommand->WriteToMemory(this, ppBytes, pNumBytes);
  769. // detach from esd descriptor params
  770. if (pAudioOd) {
  771. pAudioOd->SetProperty(4, NULL);
  772. }
  773. if (pVideoOd) {
  774. pVideoOd->SetProperty(4, NULL);
  775. }
  777. // then destroy
  778. delete pCommand;
  779. }
  781. void MP4File::CreateIsmaSceneCommand(
  782. bool hasAudio,
  783. bool hasVideo,
  784. u_int8_t** ppBytes,
  785. u_int64_t* pNumBytes)
  786. {
  787. // from ISMA 1.0 Tech Spec Appendix E
  788. static u_int8_t bifsAudioOnly[] = {
  789. 0xC0, 0x10, 0x12, 
  790. 0x81, 0x30, 0x2A, 0x05, 0x7C
  791. };
  792. static u_int8_t bifsVideoOnly[] = {
  793. 0xC0, 0x10, 0x12, 
  794. 0x61, 0x04, 0x88, 0x50, 0x45, 0x05, 0x3F, 0x00
  795. };
  796. static u_int8_t bifsAudioVideo[] = {
  797. 0xC0, 0x10, 0x12, 
  798. 0x81, 0x30, 0x2A, 0x05, 0x72,
  799. 0x61, 0x04, 0x88, 0x50, 0x45, 0x05, 0x3F, 0x00
  800. };
  802. if (hasAudio && hasVideo) {
  803. *pNumBytes = sizeof(bifsAudioVideo);
  804. *ppBytes = (u_int8_t*)MP4Malloc(*pNumBytes);
  805. memcpy(*ppBytes, bifsAudioVideo, sizeof(bifsAudioVideo));
  807. } else if (hasAudio) {
  808. *pNumBytes = sizeof(bifsAudioOnly);
  809. *ppBytes = (u_int8_t*)MP4Malloc(*pNumBytes);
  810. memcpy(*ppBytes, bifsAudioOnly, sizeof(bifsAudioOnly));
  812. } else if (hasVideo) {
  813. *pNumBytes = sizeof(bifsVideoOnly);
  814. *ppBytes = (u_int8_t*)MP4Malloc(*pNumBytes);
  815. memcpy(*ppBytes, bifsVideoOnly, sizeof(bifsVideoOnly));
  816. } else {
  817. *pNumBytes = 0;
  818. *ppBytes = NULL;
  819. }
  820. }