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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mpeg4.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. 2000-2002.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  */
  22. /* 
  23.  * Notes:
  24.  *  - file formatted with tabstops == 4 spaces 
  25.  */
  27. #include <mp4av_common.h>
  29. extern "C" bool MP4AV_Mpeg4ParseVosh(
  30.      u_int8_t* pVoshBuf, 
  31.      u_int32_t voshSize,
  32.      u_int8_t* pProfileLevel)
  33. {
  34. CMemoryBitstream vosh;
  36. vosh.SetBytes(pVoshBuf, voshSize);
  38. try {
  39. vosh.GetBits(32); // start code
  40. *pProfileLevel = vosh.GetBits(8);
  41. }
  42. catch (int e) {
  43. return false;
  44. }
  46. return true;
  47. }
  49. extern "C" bool MP4AV_Mpeg4CreateVosh(
  50. u_int8_t** ppBytes,
  51. u_int32_t* pNumBytes,
  52. u_int8_t profileLevel)
  53. {
  54. CMemoryBitstream vosh;
  56. try {
  57. if (*ppBytes) {
  58. // caller must guarantee buffer against overrun
  59. memset((*ppBytes) + (*pNumBytes), 0, 5);
  60. vosh.SetBytes(*ppBytes, (*pNumBytes) + 5);
  61. vosh.SetBitPosition((*pNumBytes) << 3);
  62. } else {
  63. vosh.AllocBytes(5);
  64. }
  66. vosh.PutBits(MP4AV_MPEG4_SYNC, 24);
  67. vosh.PutBits(MP4AV_MPEG4_VOSH_START, 8);
  68. vosh.PutBits(profileLevel, 8);
  70. *ppBytes = vosh.GetBuffer();
  71. *pNumBytes = vosh.GetNumberOfBytes();
  72. }
  73. catch (int e) {
  74. return false;
  75. }
  77. return true;
  78. }
  80. extern "C" bool MP4AV_Mpeg4CreateVo(
  81. u_int8_t** ppBytes,
  82. u_int32_t* pNumBytes,
  83. u_int8_t objectId)
  84. {
  85. CMemoryBitstream vo;
  87. try {
  88. if (*ppBytes) {
  89. // caller must guarantee buffer against overrun
  90. memset((*ppBytes) + (*pNumBytes), 0, 9);
  91. vo.SetBytes(*ppBytes, *pNumBytes + 9);
  92. vo.SetBitPosition((*pNumBytes) << 3);
  93. } else {
  94. vo.AllocBytes(9);
  95. }
  97. vo.PutBits(MP4AV_MPEG4_SYNC, 24);
  98. vo.PutBits(MP4AV_MPEG4_VO_START, 8);
  99. vo.PutBits(0x08, 8); // no verid, priority, or signal type
  100. vo.PutBits(MP4AV_MPEG4_SYNC, 24);
  101. vo.PutBits(objectId - 1, 8);
  103. *ppBytes = vo.GetBuffer();
  104. *pNumBytes = vo.GetNumberOfBytes();
  105. }
  106. catch (int e) {
  107. return false;
  108. }
  110. return true;
  111. }
  113. extern "C" bool MP4AV_Mpeg4ParseVol(
  114. u_int8_t* pVolBuf, 
  115. u_int32_t volSize,
  116. u_int8_t* pTimeBits, 
  117. u_int16_t* pTimeTicks, 
  118. u_int16_t* pFrameDuration, 
  119. u_int16_t* pFrameWidth, 
  120. u_int16_t* pFrameHeight)
  121. {
  122. CMemoryBitstream vol;
  124. vol.SetBytes(pVolBuf, volSize);
  126. try {
  127. vol.SkipBits(32); // start code
  129. vol.SkipBits(1); // random accessible vol
  130. vol.SkipBits(8); // object type id
  131. u_int8_t verid = 0;
  132. if (vol.GetBits(1)) { // is object layer id
  133. verid = vol.GetBits(4); // object layer verid
  134. vol.SkipBits(3); // object layer priority
  135. }
  136. if (vol.GetBits(4) == 0xF) {  // aspect ratio info
  137. vol.SkipBits(8); // par width
  138. vol.SkipBits(8); // par height
  139. }
  140. if (vol.GetBits(1)) { // vol control parameters
  141. vol.SkipBits(2); // chroma format
  142. vol.SkipBits(1); // low delay
  143. if (vol.GetBits(1)) { // vbv parameters
  144. vol.SkipBits(15); // first half bit rate
  145. vol.SkipBits(1); // marker bit
  146. vol.SkipBits(15); // latter half bit rate
  147. vol.SkipBits(1); // marker bit
  148. vol.SkipBits(15); // first half vbv buffer size
  149. vol.SkipBits(1); // marker bit
  150. vol.SkipBits(3); // latter half vbv buffer size
  151. vol.SkipBits(11); // first half vbv occupancy
  152. vol.SkipBits(1); // marker bit
  153. vol.SkipBits(15); // latter half vbv occupancy
  154. vol.SkipBits(1); // marker bit
  155. }
  156. }
  157. u_int8_t shape = vol.GetBits(2); // object layer shape
  158. if (shape == 3 /* GRAYSCALE */ && verid != 1) {
  159. vol.SkipBits(4); // object layer shape extension
  160. }
  161. vol.SkipBits(1); // marker bit
  162. *pTimeTicks = vol.GetBits(16); // vop time increment resolution 
  164. u_int8_t i;
  165. u_int32_t powerOf2 = 1;
  166. for (i = 0; i < 16; i++) {
  167. if (*pTimeTicks < powerOf2) {
  168. break;
  169. }
  170. powerOf2 <<= 1;
  171. }
  172. *pTimeBits = i;
  174. vol.SkipBits(1); // marker bit
  175. if (vol.GetBits(1)) { // fixed vop rate
  176. // fixed vop time increment
  177. *pFrameDuration = vol.GetBits(*pTimeBits); 
  178. } else {
  179. *pFrameDuration = 0;
  180. }
  181. if (shape == 0 /* RECTANGULAR */) {
  182. vol.SkipBits(1); // marker bit
  183. *pFrameWidth = vol.GetBits(13); // object layer width
  184. vol.SkipBits(1); // marker bit
  185. *pFrameHeight = vol.GetBits(13);// object layer height
  186. vol.SkipBits(1); // marker bit
  187. } else {
  188. *pFrameWidth = 0;
  189. *pFrameHeight = 0;
  190. }
  191. // there's more, but we don't need it
  192. }
  193. catch (int e) {
  194. return false;
  195. }
  197. return true;
  198. }
  200. extern "C" bool MP4AV_Mpeg4CreateVol(
  201. u_int8_t** ppBytes,
  202. u_int32_t* pNumBytes,
  203. u_int8_t profile,
  204. float frameRate,
  205. bool shortTime,
  206. bool variableRate,
  207. u_int16_t width,
  208. u_int16_t height,
  209. u_int8_t quantType,
  210. u_int8_t* pTimeBits)
  211. {
  212. CMemoryBitstream vol;
  214. try {
  215. if (*ppBytes) {
  216. // caller must guarantee buffer against overrun
  217. memset((*ppBytes) + (*pNumBytes), 0, 20);
  218. vol.SetBytes(*ppBytes, *pNumBytes + 20);
  219. vol.SetBitPosition((*pNumBytes) << 3);
  220. } else {
  221. vol.AllocBytes(20);
  222. }
  224. /* VOL - Video Object Layer */
  225. vol.PutBits(MP4AV_MPEG4_SYNC, 24);
  226. vol.PutBits(MP4AV_MPEG4_VOL_START, 8);
  228. /* 1 bit - random access = 0 (1 only if every VOP is an I frame) */
  229. vol.PutBits(0, 1);
  230. /*
  231.  * 8 bits - type indication 
  232.  *  = 1 (simple profile)
  233.  *  = 4 (main profile)
  234.  */
  235. vol.PutBits(profile, 8);
  236. /* 1 bit - is object layer id = 1 */
  237. vol.PutBits(1, 1);
  238. /* 4 bits - visual object layer ver id = 2 */
  239. vol.PutBits(2, 4); 
  240. /* 3 bits - visual object layer priority = 1 */
  241. vol.PutBits(1, 3); 
  243. /* 4 bits - aspect ratio info = 1 (square pixels) */
  244. vol.PutBits(1, 4);
  245. /* 1 bit - VOL control params = 0 */
  246. vol.PutBits(0, 1);
  247. /* 2 bits - VOL shape = 0 (rectangular) */
  248. vol.PutBits(0, 2);
  249. /* 1 bit - marker = 1 */
  250. vol.PutBits(1, 1);
  252. u_int16_t ticks;
  253. if (shortTime /* && frameRate == (float)((int)frameRate) */) {
  254. ticks = (u_int16_t)(frameRate + 0.5);
  255. } else {
  256. ticks = 30000;
  257. }
  258. /* 16 bits - VOP time increment resolution */
  259. vol.PutBits(ticks, 16);
  260. /* 1 bit - marker = 1 */
  261. vol.PutBits(1, 1);
  263. u_int8_t rangeBits = 1;
  264. while (ticks > (1 << rangeBits)) {
  265. rangeBits++;
  266. }
  267. if (pTimeBits) {
  268. *pTimeBits = rangeBits;
  269. }
  271. /* 1 bit - fixed vop rate = 0 or 1 */
  272. if (variableRate) {
  273. vol.PutBits(0, 1);
  274. } else {
  275. vol.PutBits(1, 1);
  277. u_int16_t frameDuration = 
  278. (u_int16_t)((float)ticks / frameRate);
  280. /* 1-16 bits - fixed vop time increment in ticks */
  281. vol.PutBits(frameDuration, rangeBits);
  282. }
  283. /* 1 bit - marker = 1 */
  284. vol.PutBits(1, 1);
  285. /* 13 bits - VOL width */
  286. vol.PutBits(width, 13);
  287. /* 1 bit - marker = 1 */
  288. vol.PutBits(1, 1);
  289. /* 13 bits - VOL height */
  290. vol.PutBits(height, 13);
  291. /* 1 bit - marker = 1 */
  292. vol.PutBits(1, 1);
  293. /* 1 bit - interlaced = 0 */
  294. vol.PutBits(0, 1);
  296. /* 1 bit - overlapped block motion compensation disable = 1 */
  297. vol.PutBits(1, 1);
  298. /* 2 bits - sprite usage = 0 */
  299. vol.PutBits(0, 2);
  300. /* 1 bit - not 8 bit pixels = 0 */
  301. vol.PutBits(0, 1);
  302. /* 1 bit - quant type = 0 */
  303. vol.PutBits(quantType, 1);
  304. if (quantType) {
  305. /* 1 bit - load intra quant mat = 0 */
  306. vol.PutBits(0, 1);
  307. /* 1 bit - load inter quant mat = 0 */
  308. vol.PutBits(0, 1);
  309. }
  310. /* 1 bit - quarter pixel = 0 */
  311. vol.PutBits(0, 1);
  312. /* 1 bit - complexity estimation disable = 1 */
  313. vol.PutBits(1, 1);
  314. /* 1 bit - resync marker disable = 1 */
  315. vol.PutBits(1, 1);
  316. /* 1 bit - data partitioned = 0 */
  317. vol.PutBits(0, 1);
  318. /* 1 bit - newpred = 0 */
  319. vol.PutBits(0, 1);
  320. /* 1 bit - reduced resolution vop = 0 */
  321. vol.PutBits(0, 1);
  322. /* 1 bit - scalability = 0 */
  323. vol.PutBits(0, 1);
  325. /* pad to byte boundary with 0 then as many 1's as needed */
  326. vol.PutBits(0, 1);
  327. if ((vol.GetBitPosition() & 7) != 0) {
  328. vol.PutBits(0xFF, 8 - (vol.GetBitPosition() & 7));
  329. }
  331. *ppBytes = vol.GetBuffer();
  332. *pNumBytes = vol.GetBitPosition() >> 3;
  333. }
  334. catch (int e) {
  335. return false;
  336. }
  338. return true;
  339. }
  341. extern "C" bool MP4AV_Mpeg4ParseGov(
  342. u_int8_t* pGovBuf, 
  343. u_int32_t govSize,
  344. u_int8_t* pHours, 
  345. u_int8_t* pMinutes, 
  346. u_int8_t* pSeconds)
  347. {
  348. CMemoryBitstream gov;
  350. gov.SetBytes(pGovBuf, govSize);
  352. try {
  353. gov.SkipBits(32); // start code
  354. *pHours = gov.GetBits(5);
  355. *pMinutes = gov.GetBits(6);
  356. gov.SkipBits(1); // marker bit
  357. *pSeconds = gov.GetBits(6);
  358. }
  359. catch (int e) {
  360. return false;
  361. }
  363. return true;
  364. }
  366. extern "C" bool MP4AV_Mpeg4ParseVop(
  367. u_int8_t* pVopBuf, 
  368. u_int32_t vopSize,
  369. u_char* pVopType, 
  370. u_int8_t timeBits, 
  371. u_int16_t timeTicks, 
  372. u_int32_t* pVopTimeIncrement)
  373. {
  374. CMemoryBitstream vop;
  376. vop.SetBytes(pVopBuf, vopSize);
  378. try {
  379. vop.SkipBits(32); // skip start code
  381. switch (vop.GetBits(2)) {
  382. case 0:
  383. /* Intra */
  384. *pVopType = 'I';
  385. break;
  386. case 1:
  387. /* Predictive */
  388. *pVopType = 'P';
  389. break;
  390. case 2:
  391. /* Bidirectional Predictive */
  392. *pVopType = 'B';
  393. break;
  394. case 3:
  395. /* Sprite */
  396. *pVopType = 'S';
  397. break;
  398. }
  400. if (!pVopTimeIncrement) {
  401. return true;
  402. }
  404. u_int8_t numSecs = 0;
  405. while (vop.GetBits(1) != 0) {
  406. numSecs++;
  407. }
  408. vop.SkipBits(1); // skip marker
  409. u_int16_t numTicks = vop.GetBits(timeBits);
  410. *pVopTimeIncrement = (numSecs * timeTicks) + numTicks; 
  411. }
  412. catch (int e) {
  413. return false;
  414. }
  416. return true;
  417. }
  419. // Map from ISO IEC 14496-2:2000 Appendix G 
  420. // to ISO IEC 14496-1:2001 8.6.4.2 Table 6
  421. extern "C" u_int8_t 
  422. MP4AV_Mpeg4VideoToSystemsProfileLevel(u_int8_t videoProfileLevel)
  423. {
  424. switch (videoProfileLevel) {
  425. // Simple Profile
  426. case 0x01: // L1
  427. return 0x03;
  428. case 0x02: // L2
  429. return 0x02;
  430. case 0x03: // L3
  431. return 0x01;
  432. // Simple Scalable Profile
  433. case 0x11: // L1
  434. return 0x05;
  435. case 0x12: // L2
  436. return 0x04;
  437. // Core Profile
  438. case 0x21: // L1
  439. return 0x07;
  440. case 0x22: // L2
  441. return 0x06;
  442. // Main Profile
  443. case 0x32: // L2
  444. return 0x0A;
  445. case 0x33: // L3
  446. return 0x09;
  447. case 0x34: // L4
  448. return 0x08;
  449. // N-bit Profile
  450. case 0x42: // L2
  451. return 0x0B;
  452. // Scalable Texture
  453. case 0x51: // L1
  454. return 0x12;
  455. case 0x52: // L2
  456. return 0x11;
  457. case 0x53: // L3
  458. return 0x10;
  459. // Simple Face Animation Profile
  460. case 0x61: // L1
  461. return 0x14;
  462. case 0x62: // L2
  463. return 0x13;
  464. // Simple FBA Profile
  465. case 0x63: // L1
  466. case 0x64: // L2
  467. return 0xFE;
  468. // Basic Animated Texture Profile
  469. case 0x71: // L1
  470. return 0x0F;
  471. case 0x72: // L2
  472. return 0x0E;
  473. // Hybrid Profile
  474. case 0x81: // L1
  475. return 0x0D;
  476. case 0x82: // L2
  477. return 0x0C;
  478. // Advanced Real Time Simple Profile
  479. case 0x91: // L1
  480. case 0x92: // L2
  481. case 0x93: // L3
  482. case 0x94: // L4
  483. // Core Scalable Profile
  484. case 0xA1: // L1
  485. case 0xA2: // L2
  486. case 0xA3: // L3
  487. // Advanced Coding Efficiency Profle
  488. case 0xB1: // L1
  489. case 0xB2: // L2
  490. case 0xB3: // L3
  491. case 0xB4: // L4
  492. // Advanced Core Profile
  493. case 0xC1: // L1
  494. case 0xC2: // L2
  495. // Advanced Scalable Texture Profile
  496. case 0xD1: // L1
  497. case 0xD2: // L2
  498. case 0xD3: // L3
  499. // from draft amendments
  500. // Simple Studio
  501. case 0xE1: // L1
  502. case 0xE2: // L2
  503. case 0xE3: // L3
  504. case 0xE4: // L4
  505. // Core Studio Profile
  506. case 0xE5: // L1
  507. case 0xE6: // L2
  508. case 0xE7: // L3
  509. case 0xE8: // L4
  510. // Advanced Simple Profile
  511. case 0xF1: // L0
  512. case 0xF2: // L1
  513. case 0xF3: // L2
  514. case 0xF4: // L3
  515. case 0xF5: // L4
  516. // Fine Granularity Scalable Profile
  517. case 0xF6: // L0
  518. case 0xF7: // L1
  519. case 0xF8: // L2
  520. case 0xF9: // L3
  521. case 0xFA: // L4
  522. default:
  523. return 0xFE;
  524. }
  525. }
  527. extern "C" u_char MP4AV_Mpeg4GetVopType(u_int8_t* pVopBuf, u_int32_t vopSize)
  528. {
  529. u_char vopType;
  531. if (MP4AV_Mpeg4ParseVop(pVopBuf, vopSize, &vopType, 0, 0, NULL)) {
  532. return vopType;
  533. }
  535. return 0;
  536. }