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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

file_mp4_recorder.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, 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  * Dave Mackie dmackie@cisco.com
  20.  * Bill May  wmay@cisco.com
  21.  */
  23. #include "mp4live.h"
  24. #include "file_mp4_recorder.h"
  25. #include "video_v4l_source.h"
  28. int CMp4Recorder::ThreadMain(void) 
  29. {
  30. while (SDL_SemWait(m_myMsgQueueSemaphore) == 0) {
  31. CMsg* pMsg = m_myMsgQueue.get_message();
  33. if (pMsg != NULL) {
  34. switch (pMsg->get_value()) {
  35. case MSG_NODE_STOP_THREAD:
  36. DoStopRecord();
  37. delete pMsg;
  38. return 0;
  39. case MSG_NODE_START:
  40. DoStartRecord();
  41. break;
  42. case MSG_NODE_STOP:
  43. DoStopRecord();
  44. break;
  45. case MSG_SINK_FRAME:
  46. size_t dontcare;
  47. DoWriteFrame((CMediaFrame*)pMsg->get_message(dontcare));
  48. break;
  49. }
  51. delete pMsg;
  52. }
  53. }
  55. return -1;
  56. }
  58. void CMp4Recorder::DoStartRecord()
  59. {
  60. if (m_sink) {
  61. return;
  62. }
  64. // enable huge file mode in mp4 if estimated size goes over 1 GB
  65. bool hugeFile = 
  66. m_pConfig->m_recordEstFileSize > 1000000000;
  67. u_int32_t verbosity =
  68. MP4_DETAILS_ERROR /* | MP4_DETAILS_WRITE_ALL */;
  70. if (m_pConfig->GetBoolValue(CONFIG_RECORD_MP4_OVERWRITE)) {
  71. m_mp4File = MP4Create(
  72. m_pConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME),
  73. verbosity, hugeFile);
  74. } else {
  75. m_mp4File = MP4Modify(
  76. m_pConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME),
  77. verbosity);
  78. }
  80. if (!m_mp4File) {
  81. return;
  82. }
  84. m_rawVideoTrackId = MP4_INVALID_TRACK_ID;
  85. m_encodedVideoTrackId = MP4_INVALID_TRACK_ID;
  86. m_rawAudioTrackId = MP4_INVALID_TRACK_ID;
  87. m_encodedAudioTrackId = MP4_INVALID_TRACK_ID;
  89. m_canRecordAudio = true;
  91. m_rawAudioTimeScale = m_encodedAudioTimeScale = 
  92. m_pConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE);
  94. if (m_pConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)
  95.   && (m_pConfig->GetBoolValue(CONFIG_RECORD_RAW_VIDEO)
  96.     || m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_VIDEO))) {
  97. m_movieTimeScale = m_videoTimeScale;
  99. } else if (m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_AUDIO)) {
  100. m_movieTimeScale = m_encodedAudioTimeScale;
  102. } else {
  103. m_movieTimeScale = m_rawAudioTimeScale;
  104. }
  105. MP4SetTimeScale(m_mp4File, m_movieTimeScale);
  107. if (m_pConfig->GetBoolValue(CONFIG_VIDEO_ENABLE)) {
  109. if (m_pConfig->GetBoolValue(CONFIG_RECORD_RAW_VIDEO)) {
  110. m_rawVideoFrameNum = 1;
  111. m_canRecordAudio = false;
  113. m_rawVideoTrackId = MP4AddVideoTrack(
  114. m_mp4File,
  115. m_videoTimeScale,
  116. MP4_INVALID_DURATION,
  117. m_pConfig->m_videoWidth, 
  118. m_pConfig->m_videoHeight,
  119. MP4_YUV12_VIDEO_TYPE);
  121. if (m_rawVideoTrackId == MP4_INVALID_TRACK_ID) {
  122. error_message("can't create raw video track");
  123. goto start_failure;
  124. }
  126. MP4SetVideoProfileLevel(m_mp4File, 0xFF);
  127. }
  129. if (m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_VIDEO)) {
  130. m_encodedVideoFrameNum = 1;
  131. m_canRecordAudio = false;
  133. m_encodedVideoTrackId = MP4AddVideoTrack(
  134. m_mp4File,
  135. m_videoTimeScale,
  136. MP4_INVALID_DURATION,
  137. m_pConfig->m_videoWidth, 
  138. m_pConfig->m_videoHeight,
  139. MP4_MPEG4_VIDEO_TYPE);
  141. if (m_encodedVideoTrackId == MP4_INVALID_TRACK_ID) {
  142. error_message("can't create encoded video track");
  143. goto start_failure;
  144. }
  146. MP4SetVideoProfileLevel(m_mp4File, 
  147. m_pConfig->GetIntegerValue(CONFIG_VIDEO_PROFILE_ID));
  149. MP4SetTrackESConfiguration(m_mp4File, m_encodedVideoTrackId,
  150. m_pConfig->m_videoMpeg4Config, 
  151. m_pConfig->m_videoMpeg4ConfigLength); 
  153. }
  154. }
  156. if (m_pConfig->GetBoolValue(CONFIG_AUDIO_ENABLE)) {
  158. if (m_pConfig->GetBoolValue(CONFIG_RECORD_RAW_AUDIO)) {
  159. m_rawAudioFrameNum = 1;
  160. m_rawAudioDuration = 0;
  162. m_rawAudioTrackId = MP4AddAudioTrack(
  163. m_mp4File, 
  164. m_rawAudioTimeScale, 
  165. 0,
  166. MP4_PCM16_AUDIO_TYPE);
  168. if (m_rawAudioTrackId == MP4_INVALID_TRACK_ID) {
  169. error_message("can't create raw audio track");
  170. goto start_failure;
  171. }
  173. MP4SetAudioProfileLevel(m_mp4File, 0xFF);
  174. }
  176. if (m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_AUDIO)) {
  177. m_encodedAudioFrameNum = 1;
  178. m_encodedAudioDuration = 0;
  180. u_int8_t audioType;
  182. if (!strcasecmp(m_pConfig->GetStringValue(CONFIG_AUDIO_ENCODING),
  183.   AUDIO_ENCODING_AAC)) {
  184. audioType = MP4_MPEG4_AUDIO_TYPE;
  185. MP4SetAudioProfileLevel(m_mp4File, 0x0F);
  186. } else {
  187. audioType = MP4_MP3_AUDIO_TYPE;
  188. MP4SetAudioProfileLevel(m_mp4File, 0xFE);
  189. }
  191. m_encodedAudioTrackId = MP4AddAudioTrack(
  192. m_mp4File, 
  193. m_encodedAudioTimeScale, 
  194. MP4_INVALID_DURATION,
  195. audioType);
  197. if (m_encodedAudioTrackId == MP4_INVALID_TRACK_ID) {
  198. error_message("can't create encoded audio track");
  199. goto start_failure;
  200. }
  202. if (!strcasecmp(m_pConfig->GetStringValue(CONFIG_AUDIO_ENCODING),
  203.   AUDIO_ENCODING_AAC)) {
  204. u_int8_t* pConfig = NULL;
  205. u_int32_t configLength = 0;
  207. MP4AV_AacGetConfiguration(
  208. &pConfig,
  209. &configLength,
  210. MP4AV_AAC_LC_PROFILE,
  211. m_pConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE),
  212. m_pConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS));
  214. MP4SetTrackESConfiguration(
  215. m_mp4File, 
  216. m_encodedAudioTrackId,
  217. pConfig, 
  218. configLength);
  219. }
  220. }
  221. }
  223. m_sink = true;
  224. return;
  226. start_failure:
  227. MP4Close(m_mp4File);
  228. m_mp4File = NULL;
  229. return;
  230. }
  232. void CMp4Recorder::DoWriteFrame(CMediaFrame* pFrame)
  233. {
  234. if (pFrame == NULL) {
  235. return;
  236. }
  237. if (!m_sink) {
  238. delete pFrame;
  239. return;
  240. }
  242. if (pFrame->GetType() == CMediaFrame::PcmAudioFrame
  243.   && m_pConfig->GetBoolValue(CONFIG_RECORD_RAW_AUDIO)) {
  245. if (m_canRecordAudio) {
  246. if (m_rawAudioFrameNum == 1) {
  247. m_rawAudioStartTimestamp = pFrame->GetTimestamp();
  248. m_rawAudioDuration = 0;
  249. }
  251. // check for audio continuity
  252. Duration skew =
  253. MP4ConvertToTrackDuration(
  254. m_mp4File, 
  255. m_rawAudioTrackId, 
  256. (pFrame->GetTimestamp() - m_rawAudioStartTimestamp)
  257. - m_rawAudioDuration,
  258. TimestampTicks);
  260. if (skew > 128) {
  261. // record audio gap
  262. MP4WriteSample(
  263. m_mp4File,
  264. m_rawAudioTrackId,
  265. NULL,
  266. 0,
  267. skew);
  268. }
  270. MP4WriteSample(
  271. m_mp4File,
  272. m_rawAudioTrackId,
  273. (u_int8_t*)pFrame->GetData(), 
  274. pFrame->GetDataLength(),
  275. pFrame->GetDataLength() 
  276. / (2 * m_pConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS)));
  278. m_rawAudioFrameNum++;
  280. m_rawAudioDuration += 
  281. pFrame->ConvertDuration(TimestampTicks);
  282. }
  284. } else if ((pFrame->GetType() == CMediaFrame::Mp3AudioFrame
  285.     || pFrame->GetType() == CMediaFrame::AacAudioFrame)
  286.   && m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_AUDIO)) {
  288. if (m_canRecordAudio) {
  289. if (m_encodedAudioFrameNum == 1) {
  290. m_encodedAudioStartTimestamp = pFrame->GetTimestamp();
  291. m_encodedAudioDuration = 0;
  292. }
  294. // check for audio continuity
  295. Duration skew =
  296. MP4ConvertToTrackDuration(
  297. m_mp4File, 
  298. m_encodedAudioTrackId, 
  299. (pFrame->GetTimestamp() - m_encodedAudioStartTimestamp)
  300. - m_encodedAudioDuration,
  301. TimestampTicks);
  303. if (skew > 128) {
  304. // record audio gap
  305. MP4WriteSample(
  306. m_mp4File,
  307. m_encodedAudioTrackId,
  308. NULL,
  309. 0,
  310. skew);
  311. }
  313. MP4WriteSample(
  314. m_mp4File,
  315. m_encodedAudioTrackId,
  316. (u_int8_t*)pFrame->GetData(), 
  317. pFrame->GetDataLength(),
  318. pFrame->ConvertDuration(m_encodedAudioTimeScale));
  320. m_encodedAudioFrameNum++;
  322. m_encodedAudioDuration += 
  323. pFrame->ConvertDuration(TimestampTicks);
  324. }
  326. } else if (pFrame->GetType() == CMediaFrame::YuvVideoFrame
  327.   && m_pConfig->GetBoolValue(CONFIG_RECORD_RAW_VIDEO)) {
  329. // let audio record if raw is the only video being recorded
  330. if (!m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_VIDEO)) {
  331. m_canRecordAudio = true;
  332. }
  334. MP4WriteSample(
  335. m_mp4File,
  336. m_rawVideoTrackId,
  337. (u_int8_t*)pFrame->GetData(), 
  338. pFrame->GetDataLength(),
  339. pFrame->ConvertDuration(m_videoTimeScale));
  341. m_rawVideoFrameNum++;
  343. } else if (pFrame->GetType() == CMediaFrame::Mpeg4VideoFrame
  344.   && m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_VIDEO)) {
  346. u_int8_t* pSample = NULL;
  347. u_int32_t sampleLength = 0;
  348. Duration sampleDuration = 
  349. pFrame->ConvertDuration(m_videoTimeScale);
  350. bool isIFrame = (MP4AV_Mpeg4GetVopType(
  351. (u_int8_t*)pFrame->GetData(), pFrame->GetDataLength()) == 'I');
  353. if (m_encodedVideoFrameNum > 1 || isIFrame) {
  354. pSample = (u_int8_t*)pFrame->GetData();
  355. sampleLength = pFrame->GetDataLength();
  357. m_canRecordAudio = true;
  359. } // else waiting for I frame at start of recording
  361. if (pSample != NULL) {
  362. MP4WriteSample(
  363. m_mp4File,
  364. m_encodedVideoTrackId,
  365. pSample, 
  366. sampleLength,
  367. sampleDuration,
  368. 0,
  369. isIFrame);
  371. m_encodedVideoFrameNum++;
  372. }
  373. }
  375. delete pFrame;
  376. }
  378. void CMp4Recorder::DoStopRecord()
  379. {
  380. if (!m_sink) {
  381. return;
  382. }
  384. bool optimize = false;
  386. // create hint tracks
  387. if (m_pConfig->GetBoolValue(CONFIG_RECORD_MP4_HINT_TRACKS)) {
  389. if (m_pConfig->GetBoolValue(CONFIG_RECORD_MP4_OPTIMIZE)) {
  390. optimize = true;
  391. }
  393. if (MP4_IS_VALID_TRACK_ID(m_encodedVideoTrackId)) {
  394. MP4AV_Rfc3016Hinter(
  395. m_mp4File, 
  396. m_encodedVideoTrackId,
  397. m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE));
  399. // LATER H.26L hinter when we have a real-time H.26L encoder
  400. }
  402. if (MP4_IS_VALID_TRACK_ID(m_encodedAudioTrackId)) {
  403. const char *encoding = 
  404. m_pConfig->GetStringValue(CONFIG_AUDIO_ENCODING);
  406. if (!strcasecmp(encoding, AUDIO_ENCODING_MP3)) {
  407. MP4AV_Rfc2250Hinter(
  408. m_mp4File, 
  409. m_encodedAudioTrackId, 
  410. false, 
  411. m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE));
  413. } else if (!strcasecmp(encoding, AUDIO_ENCODING_AAC)) {
  414. MP4AV_RfcIsmaHinter(
  415. m_mp4File, 
  416. m_encodedAudioTrackId, 
  417. false, 
  418. m_pConfig->GetIntegerValue(CONFIG_RTP_PAYLOAD_SIZE));
  419. }
  420. }
  421. }
  423. // close the mp4 file
  424. MP4Close(m_mp4File);
  425. m_mp4File = NULL;
  427. // add ISMA style OD and Scene tracks
  428. if (m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_VIDEO)
  429.   || m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_AUDIO)) {
  431. bool useIsmaTag = false;
  433. // if AAC track is present, can tag this as ISMA compliant content
  434.    if (m_pConfig->GetBoolValue(CONFIG_RECORD_ENCODED_AUDIO)
  435.   && !strcasecmp(m_pConfig->GetStringValue(CONFIG_AUDIO_ENCODING),
  436.     AUDIO_ENCODING_AAC)) {
  438. useIsmaTag = true;
  439. }
  441. MP4MakeIsmaCompliant(
  442. m_pConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME),
  443. 0,
  444. useIsmaTag);
  445. }
  447. if (optimize) {
  448. MP4Optimize(m_pConfig->GetStringValue(CONFIG_RECORD_MP4_FILE_NAME));
  449. }
  451. m_sink = false;
  452. }