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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

media_source.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. #include "mp4live.h"
  23. #include "media_source.h"
  24. #include "audio_encoder.h"
  25. #include "video_encoder.h"
  26. #include "video_util_rgb.h"
  27. #include <mp4av.h>
  30. CMediaSource::CMediaSource() 
  31. {
  32. m_pSinksMutex = SDL_CreateMutex();
  33. if (m_pSinksMutex == NULL) {
  34. debug_message("CreateMutex error");
  35. }
  36. for (int i = 0; i < MAX_SINKS; i++) {
  37. m_sinks[i] = NULL;
  38. }
  40. m_source = false;
  41. m_sourceVideo = false;
  42. m_sourceAudio = false;
  43. m_maxAheadDuration = TimestampTicks / 2 ; // 500 msec
  45. m_videoSource = this;
  46. m_videoSrcYImage = NULL;
  47. m_videoDstYImage = NULL;
  48. m_videoYResizer = NULL;
  49. m_videoSrcUVImage = NULL;
  50. m_videoDstUVImage = NULL;
  51. m_videoUVResizer = NULL;
  52. m_videoEncoder = NULL;
  53. m_videoDstPrevImage = NULL;
  54. m_videoDstPrevReconstructImage = NULL;
  55. m_videoDstPrevFrame = NULL;
  57. m_audioResampleInputBuffer = NULL;
  58. m_audioPreEncodingBuffer = NULL;
  59. m_audioEncoder = NULL;
  60. }
  62. CMediaSource::~CMediaSource() 
  63. {
  64. SDL_DestroyMutex(m_pSinksMutex);
  65. m_pSinksMutex = NULL;
  66. }
  68. bool CMediaSource::AddSink(CMediaSink* pSink) 
  69. {
  70. bool rc = false;
  72. if (SDL_LockMutex(m_pSinksMutex) == -1) {
  73. debug_message("AddSink LockMutex error");
  74. return rc;
  75. }
  76. for (int i = 0; i < MAX_SINKS; i++) {
  77. if (m_sinks[i] == NULL) {
  78. m_sinks[i] = pSink;
  79. rc = true;
  80. break;
  81. }
  82. }
  83. if (SDL_UnlockMutex(m_pSinksMutex) == -1) {
  84. debug_message("UnlockMutex error");
  85. }
  86. return rc;
  87. }
  89. void CMediaSource::RemoveSink(CMediaSink* pSink) 
  90. {
  91. if (SDL_LockMutex(m_pSinksMutex) == -1) {
  92. debug_message("RemoveSink LockMutex error");
  93. return;
  94. }
  95. for (int i = 0; i < MAX_SINKS; i++) {
  96. if (m_sinks[i] == pSink) {
  97. int j;
  98. for (j = i; j < MAX_SINKS - 1; j++) {
  99. m_sinks[j] = m_sinks[j+1];
  100. }
  101. m_sinks[j] = NULL;
  102. break;
  103. }
  104. }
  105. if (SDL_UnlockMutex(m_pSinksMutex) == -1) {
  106. debug_message("UnlockMutex error");
  107. }
  108. }
  110. void CMediaSource::RemoveAllSinks(void) 
  111. {
  112. if (SDL_LockMutex(m_pSinksMutex) == -1) {
  113. debug_message("RemoveAllSinks LockMutex error");
  114. return;
  115. }
  116. for (int i = 0; i < MAX_SINKS; i++) {
  117. if (m_sinks[i] == NULL) {
  118. break;
  119. }
  120. m_sinks[i] = NULL;
  121. }
  122. if (SDL_UnlockMutex(m_pSinksMutex) == -1) {
  123. debug_message("UnlockMutex error");
  124. }
  125. }
  127. void CMediaSource::ProcessMedia()
  128. {
  129. Duration start = GetElapsedDuration();
  131. // process ~1 second before returning to check for commands
  132. while (GetElapsedDuration() - start < (Duration)TimestampTicks) {
  134. if (m_sourceVideo && m_sourceAudio) {
  135. bool endOfVideo = IsEndOfVideo();
  136. bool endOfAudio = IsEndOfAudio();
  138. if (!endOfVideo && !endOfAudio) {
  139. if (m_videoSrcElapsedDuration <= m_audioSrcElapsedDuration) {
  140. ProcessVideo();
  141. } else {
  142. ProcessAudio();
  143. }
  144. } else if (endOfVideo && endOfAudio) {
  145. DoStopSource();
  146. break;
  147. } else if (endOfVideo) {
  148. ProcessAudio();
  149. } else { // endOfAudio
  150. ProcessVideo();
  151. }
  153. } else if (m_sourceVideo) {
  154. if (IsEndOfVideo()) {
  155. DoStopSource();
  156. break;
  157. }
  158. ProcessVideo();
  160. } else if (m_sourceAudio) {
  161. if (IsEndOfAudio()) {
  162. DoStopSource();
  163. break;
  164. }
  165. ProcessAudio();
  166. }
  167. }
  168. }
  170. Duration CMediaSource::GetElapsedDuration()
  171. {
  172. if (m_sourceVideo && m_sourceAudio) {
  173. return MIN(m_videoSrcElapsedDuration, m_audioSrcElapsedDuration);
  174. } else if (m_sourceVideo) {
  175. return m_videoSrcElapsedDuration;
  176. } else if (m_sourceAudio) {
  177. return m_audioSrcElapsedDuration;
  178. }
  179. return 0;
  180. }
  182. // slow down non-realtime sources, i.e. files
  183. // if any of the sinks require real-time semantics, i.e. RTP/UDP
  184. void CMediaSource::PaceSource()
  185. {
  186. if (m_sourceRealTime || !m_sinkRealTime) {
  187. return;
  188. }
  190. Duration realDuration =
  191. GetTimestamp() - m_startTimestamp;
  193. Duration aheadDuration =
  194. GetElapsedDuration() - realDuration;
  196. if (aheadDuration >= m_maxAheadDuration) {
  197. SDL_Delay((aheadDuration - (m_maxAheadDuration / 2)) / 1000);
  198. }
  199. }
  201. void CMediaSource::ForwardFrame(CMediaFrame* pFrame)
  202. {
  203. if (SDL_LockMutex(m_pSinksMutex) == -1) {
  204. debug_message("ForwardFrame LockMutex error");
  205. return;
  206. }
  208. for (int i = 0; i < MAX_SINKS; i++) {
  209. if (m_sinks[i] == NULL) {
  210. break;
  211. }
  212. m_sinks[i]->EnqueueFrame(pFrame);
  213. }
  215. if (SDL_UnlockMutex(m_pSinksMutex) == -1) {
  216. debug_message("UnlockMutex error");
  217. }
  219. return;
  220. }
  222. void CMediaSource::DoStopSource()
  223. {
  224. if (!m_source) {
  225. return;
  226. }
  228. DoStopVideo();
  230. DoStopAudio();
  232. m_source = false;
  233. }
  235. bool CMediaSource::InitVideo(
  236. MediaType srcType,
  237. bool realTime)
  238. {
  239. m_sourceRealTime = realTime;
  240. m_sinkRealTime = m_pConfig->GetBoolValue(CONFIG_RTP_ENABLE);
  242. m_videoSrcType = srcType;
  243. m_videoSrcFrameNumber = 0;
  244. m_audioSrcFrameNumber = 0; // ensure audio is also at zero
  246. m_videoDstType = CMediaFrame::Mpeg4VideoFrame;
  247. m_videoDstFrameRate =
  248. m_pConfig->GetFloatValue(CONFIG_VIDEO_FRAME_RATE);
  249. m_videoDstFrameDuration = 
  250. (Duration)(((float)TimestampTicks / m_videoDstFrameRate) + 0.5);
  251. m_videoDstFrameNumber = 0;
  252. m_videoDstWidth =
  253. m_pConfig->m_videoWidth;
  254. m_videoDstHeight =
  255. m_pConfig->m_videoHeight;
  256. m_videoDstAspectRatio = 
  257. (float)m_pConfig->m_videoWidth / (float)m_pConfig->m_videoHeight;
  258. m_videoDstYSize = m_videoDstWidth * m_videoDstHeight;
  259. m_videoDstUVSize = m_videoDstYSize / 4;
  260. m_videoDstYUVSize = (m_videoDstYSize * 3) / 2;
  262. // intialize encoder
  263. m_videoEncoder = VideoEncoderCreate(
  264. m_pConfig->GetStringValue(CONFIG_VIDEO_ENCODER));
  266. if (!m_videoEncoder) {
  267. return false;
  268. }
  269. if (!m_videoEncoder->Init(m_pConfig, realTime)) {
  270. delete m_videoEncoder;
  271. m_videoEncoder = NULL;
  272. return false;
  273. }
  275. m_videoWantKeyFrame = true;
  276. m_videoSkippedFrames = 0;
  277. m_videoEncodingDrift = 0;
  278. m_videoEncodingMaxDrift = m_videoDstFrameDuration;
  279. m_videoSrcElapsedDuration = 0;
  280. m_videoDstElapsedDuration = 0;
  281. m_otherTotalDrift = 0;
  282. m_otherLastTotalDrift = 0;
  284. m_videoDstPrevImage = NULL;
  285. m_videoDstPrevReconstructImage = NULL;
  286. m_videoDstPrevFrame = NULL;
  287. m_videoDstPrevFrameLength = 0;
  289. return true;
  290. }
  292. void CMediaSource::SetVideoSrcSize(
  293. u_int16_t srcWidth,
  294. u_int16_t srcHeight,
  295. u_int16_t srcStride,
  296. bool matchAspectRatios)
  297. {
  298. // N.B. InitVideo() must be called first
  300. m_videoSrcWidth = srcWidth;
  301. m_videoSrcHeight = srcHeight;
  302. m_videoSrcAspectRatio = (float)srcWidth / (float)srcHeight;
  303. m_videoMatchAspectRatios = matchAspectRatios;
  305. SetVideoSrcStride(srcStride);
  306. }
  308. void CMediaSource::SetVideoSrcStride(
  309. u_int16_t srcStride)
  310. {
  311. // N.B. SetVideoSrcSize() should be called once before 
  313. m_videoSrcYStride = srcStride;
  314. m_videoSrcUVStride = srcStride / 2;
  316. // these next three may change below
  317. m_videoSrcAdjustedHeight = m_videoSrcHeight;
  318. m_videoSrcYCrop = 0;
  319. m_videoSrcUVCrop = 0;
  321. // match aspect ratios
  322. if (m_videoMatchAspectRatios 
  323.   && fabs(m_videoSrcAspectRatio - m_videoDstAspectRatio) > 0.01) {
  325. m_videoSrcAdjustedHeight =
  326. (u_int16_t)(m_videoSrcWidth / m_videoDstAspectRatio);
  327. if ((m_videoSrcAdjustedHeight % 16) != 0) {
  328. m_videoSrcAdjustedHeight += 16 - (m_videoSrcAdjustedHeight % 16);
  329. }
  331. if (m_videoSrcAspectRatio < m_videoDstAspectRatio) {
  332. // crop src
  333. m_videoSrcYCrop = m_videoSrcYStride * 
  334. ((m_videoSrcHeight - m_videoSrcAdjustedHeight) / 2);
  335. m_videoSrcUVCrop = m_videoSrcYCrop / 4;
  336. }
  337. }
  339. m_videoSrcYSize = m_videoSrcYStride 
  340. * MAX(m_videoSrcHeight, m_videoSrcAdjustedHeight);
  341. m_videoSrcUVSize = m_videoSrcYSize / 4;
  342. m_videoSrcYUVSize = (m_videoSrcYSize * 3) / 2;
  344. // resizing
  346. DestroyVideoResizer();
  348. if (m_videoSrcWidth != m_videoDstWidth 
  349.   || m_videoSrcAdjustedHeight != m_videoDstHeight) {
  351. m_videoSrcYImage = 
  352. scale_new_image(m_videoSrcWidth, 
  353. m_videoSrcAdjustedHeight, 1);
  354. m_videoSrcYImage->span = m_videoSrcYStride;
  355. m_videoDstYImage = 
  356. scale_new_image(m_videoDstWidth, 
  357. m_videoDstHeight, 1);
  358. m_videoYResizer = 
  359. scale_image_init(m_videoDstYImage, m_videoSrcYImage, 
  360. Bell_filter, Bell_support);
  362. m_videoSrcUVImage = 
  363. scale_new_image(m_videoSrcWidth / 2, 
  364. m_videoSrcAdjustedHeight / 2, 1);
  365. m_videoSrcUVImage->span = m_videoSrcUVStride;
  366. m_videoDstUVImage = 
  367. scale_new_image(m_videoDstWidth / 2, 
  368. m_videoDstHeight / 2, 1);
  369. m_videoUVResizer = 
  370. scale_image_init(m_videoDstUVImage, m_videoSrcUVImage, 
  371. Bell_filter, Bell_support);
  372. }
  373. }
  375. void CMediaSource::ProcessVideoYUVFrame(
  376. u_int8_t* pY,
  377. u_int8_t* pU,
  378. u_int8_t* pV,
  379. u_int16_t yStride,
  380. u_int16_t uvStride,
  381. Timestamp srcFrameTimestamp)
  382. {
  383. if (m_videoSrcFrameNumber == 0 && m_audioSrcFrameNumber == 0) {
  384. m_startTimestamp = srcFrameTimestamp;
  385. }
  387. m_videoSrcFrameNumber++;
  388. m_videoSrcElapsedDuration = srcFrameTimestamp - m_startTimestamp;
  390. // drop src frames as needed to match target frame rate
  391. if (m_videoDstElapsedDuration > m_videoSrcElapsedDuration) {
  392. return;
  393. }
  395. // if we're running in real-time mode
  396. if (m_sourceRealTime) {
  398. // add any external drift (i.e. audio encoding drift)
  399. // to our drift measurement
  400. m_videoEncodingDrift += 
  401. m_otherTotalDrift - m_otherLastTotalDrift;
  402. m_otherLastTotalDrift = m_otherTotalDrift;
  404. // check if we are falling behind
  405. if (m_videoEncodingDrift >= m_videoEncodingMaxDrift) {
  406. m_videoEncodingDrift -= m_videoDstFrameDuration;
  408. if (m_videoEncodingDrift < 0) {
  409. m_videoEncodingDrift = 0;
  410. }
  412. // skip this frame
  413. m_videoSkippedFrames++;
  414. return;
  415. }
  416. }
  418. Timestamp encodingStartTimestamp = GetTimestamp();
  420. // this will either never happen (live capture)
  421. // or just happen once at startup when we discover
  422. // the stride used by the video decoder
  423. if (yStride != m_videoSrcYStride) {
  424. SetVideoSrcSize(m_videoSrcWidth, m_videoSrcHeight, 
  425. yStride, m_videoMatchAspectRatios);
  426. }
  428. u_int8_t* mallocedYuvImage = NULL;
  430. // crop to desired aspect ratio (may be a no-op)
  431. u_int8_t* yImage = pY + m_videoSrcYCrop;
  432. u_int8_t* uImage = pU + m_videoSrcUVCrop;
  433. u_int8_t* vImage = pV + m_videoSrcUVCrop;
  435. // Note: caller is responsible for adding any padding that is needed
  437. // resize image if necessary
  438. if (m_videoYResizer) {
  439. u_int8_t* resizedYUV = 
  440. (u_int8_t*)Malloc(m_videoDstYUVSize);
  442. u_int8_t* resizedY = 
  443. resizedYUV;
  444. u_int8_t* resizedU = 
  445. resizedYUV + m_videoDstYSize;
  446. u_int8_t* resizedV = 
  447. resizedYUV + m_videoDstYSize + m_videoDstUVSize;
  449. m_videoSrcYImage->data = yImage;
  450. m_videoDstYImage->data = resizedY;
  451. scale_image_process(m_videoYResizer);
  453. m_videoSrcUVImage->data = uImage;
  454. m_videoDstUVImage->data = resizedU;
  455. scale_image_process(m_videoUVResizer);
  457. m_videoSrcUVImage->data = vImage;
  458. m_videoDstUVImage->data = resizedV;
  459. scale_image_process(m_videoUVResizer);
  461. // done with the original source image
  462. // this may be NULL
  463. free(mallocedYuvImage);
  465. // switch over to resized version
  466. mallocedYuvImage = resizedYUV;
  467. yImage = resizedY;
  468. uImage = resizedU;
  469. vImage = resizedV;
  470. yStride = m_videoDstWidth;
  471. uvStride = yStride / 2;
  472. }
  474. // if we want encoded video frames
  475. if (m_pConfig->m_videoEncode) {
  477. // call video encoder
  478. bool rc = m_videoEncoder->EncodeImage(
  479. yImage, uImage, vImage, 
  480. yStride, uvStride,
  481. m_videoWantKeyFrame);
  483. if (!rc) {
  484. debug_message("Can't encode image!");
  485. free(mallocedYuvImage);
  486. return;
  487. }
  489. // clear want key frame flag
  490. m_videoWantKeyFrame = false;
  491. }
  493. Timestamp dstPrevFrameTimestamp =
  494. m_startTimestamp + m_videoDstElapsedDuration;
  496. // calculate previous frame duration
  497. Duration dstPrevFrameDuration = m_videoDstFrameDuration;
  498. m_videoDstElapsedDuration += m_videoDstFrameDuration;
  500. if (m_sourceRealTime && m_videoSrcFrameNumber > 0) {
  502. // first adjust due to skipped frames
  503. Duration dstPrevFrameAdjustment = 
  504. m_videoSkippedFrames * m_videoDstFrameDuration;
  506. dstPrevFrameDuration += dstPrevFrameAdjustment;
  507. m_videoDstElapsedDuration += dstPrevFrameAdjustment;
  509. // next check our duration against real elasped time
  510. Duration lag = m_videoSrcElapsedDuration - m_videoDstElapsedDuration;
  512. if (lag > 0) {
  513. // adjust by integral number of target duration units
  514. dstPrevFrameAdjustment = 
  515. (lag / m_videoDstFrameDuration) * m_videoDstFrameDuration;
  517. dstPrevFrameDuration += dstPrevFrameAdjustment;
  518. m_videoDstElapsedDuration += dstPrevFrameAdjustment;
  519. }
  520. }
  522. // forward encoded video to sinks
  523. if (m_pConfig->m_videoEncode) {
  524. if (m_videoDstPrevFrame) {
  525. CMediaFrame* pFrame = new CMediaFrame(
  526. CMediaFrame::Mpeg4VideoFrame, 
  527. m_videoDstPrevFrame, 
  528. m_videoDstPrevFrameLength,
  529. dstPrevFrameTimestamp, 
  530. dstPrevFrameDuration);
  531. ForwardFrame(pFrame);
  532. delete pFrame;
  533. }
  535. // hold onto this encoded vop until next one is ready
  536. m_videoEncoder->GetEncodedImage(
  537. &m_videoDstPrevFrame, &m_videoDstPrevFrameLength);
  538. }
  540. // forward raw video to sinks
  541. if (m_pConfig->SourceRawVideo()) {
  543. if (m_videoDstPrevImage) {
  544. CMediaFrame* pFrame =
  545. new CMediaFrame(
  546. CMediaFrame::YuvVideoFrame, 
  547. m_videoDstPrevImage, 
  548. m_videoDstYUVSize,
  549. dstPrevFrameTimestamp, 
  550. dstPrevFrameDuration);
  551. ForwardFrame(pFrame);
  552. delete pFrame;
  553. }
  555. m_videoDstPrevImage = (u_int8_t*)Malloc(m_videoDstYUVSize);
  557. imgcpy(m_videoDstPrevImage, 
  558. yImage, 
  559. m_videoDstWidth,
  560. m_videoDstHeight,
  561. yStride);
  562. imgcpy(m_videoDstPrevImage + m_videoDstYSize,
  563. uImage, 
  564. m_videoDstWidth / 2,
  565. m_videoDstHeight / 2,
  566. uvStride);
  567. imgcpy(m_videoDstPrevImage + m_videoDstYSize + m_videoDstUVSize,
  568. vImage, 
  569. m_videoDstWidth / 2,
  570. m_videoDstHeight / 2,
  571. uvStride);
  572. }
  574. // forward reconstructed video to sinks
  575. if (m_pConfig->m_videoEncode
  576.   && m_pConfig->GetBoolValue(CONFIG_VIDEO_ENCODED_PREVIEW)) {
  578. if (m_videoDstPrevReconstructImage) {
  579. CMediaFrame* pFrame =
  580. new CMediaFrame(CMediaFrame::ReconstructYuvVideoFrame, 
  581. m_videoDstPrevReconstructImage, 
  582. m_videoDstYUVSize,
  583. dstPrevFrameTimestamp, 
  584. dstPrevFrameDuration);
  585. ForwardFrame(pFrame);
  586. delete pFrame;
  587. }
  589. m_videoDstPrevReconstructImage = 
  590. (u_int8_t*)Malloc(m_videoDstYUVSize);
  592. m_videoEncoder->GetReconstructedImage(
  593. m_videoDstPrevReconstructImage,
  594. m_videoDstPrevReconstructImage 
  595. + m_videoDstYSize,
  596. m_videoDstPrevReconstructImage
  597. + m_videoDstYSize + m_videoDstUVSize);
  598. }
  600. m_videoDstFrameNumber++;
  602. // calculate how we're doing versus target frame rate
  603. // this is used to decide if we need to drop frames
  604. if (m_sourceRealTime) {
  605. // reset skipped frames
  606. m_videoSkippedFrames = 0;
  608. Duration drift =
  609. (GetTimestamp() - encodingStartTimestamp) 
  610. - m_videoDstFrameDuration;
  612. if (drift > 0) {
  613. m_videoEncodingDrift += drift;
  614. }
  615. }
  617. free(mallocedYuvImage);
  618. return;
  619. }
  621. void CMediaSource::DoStopVideo()
  622. {
  623. DestroyVideoResizer();
  625. if (m_videoEncoder) {
  626. m_videoEncoder->Stop();
  627. delete m_videoEncoder;
  628. m_videoEncoder = NULL;
  629. }
  631. m_sourceVideo = false;
  632. }
  634. void CMediaSource::DestroyVideoResizer()
  635. {
  636. if (m_videoSrcYImage) {
  637. scale_free_image(m_videoSrcYImage);
  638. m_videoSrcYImage = NULL;
  639. }
  640. if (m_videoDstYImage) {
  641. scale_free_image(m_videoDstYImage);
  642. m_videoDstYImage = NULL;
  643. }
  644. if (m_videoYResizer) {
  645. scale_image_done(m_videoYResizer);
  646. m_videoYResizer = NULL;
  647. }
  648. if (m_videoSrcUVImage) {
  649. scale_free_image(m_videoSrcUVImage);
  650. m_videoSrcUVImage = NULL;
  651. }
  652. if (m_videoDstUVImage) {
  653. scale_free_image(m_videoDstUVImage);
  654. m_videoDstUVImage = NULL;
  655. }
  656. if (m_videoUVResizer) {
  657. scale_image_done(m_videoUVResizer);
  658. m_videoUVResizer = NULL;
  659. }
  660. }
  662. bool CMediaSource::InitAudio(
  663. bool realTime)
  664. {
  665. m_sourceRealTime = realTime;
  666. m_sinkRealTime = m_pConfig->GetBoolValue(CONFIG_RTP_ENABLE);
  667. m_audioSrcSampleNumber = 0;
  668. m_audioSrcFrameNumber = 0;
  669. m_videoSrcFrameNumber = 0; // ensure video is also at zero
  671. // audio destination info
  672. char* dstEncoding =
  673. m_pConfig->GetStringValue(CONFIG_AUDIO_ENCODING);
  675. if (!strcasecmp(dstEncoding, AUDIO_ENCODING_MP3)) {
  676. m_audioDstType = CMediaFrame::Mp3AudioFrame;
  677. } else if (!strcasecmp(dstEncoding, AUDIO_ENCODING_AAC)) {
  678. m_audioDstType = CMediaFrame::AacAudioFrame;
  679. } else {
  680. debug_message("unknown dest audio encoding");
  681. return false;
  682. }
  683. m_audioDstChannels =
  684. m_pConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS);
  685. m_audioDstSampleRate =
  686. m_pConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE);
  687. m_audioDstSampleNumber = 0;
  688. m_audioDstFrameNumber = 0;
  689. m_audioDstRawSampleNumber = 0;
  690. m_audioDstRawFrameNumber = 0;
  692. m_audioSrcElapsedDuration = 0;
  693. m_audioDstElapsedDuration = 0;
  695. return true;
  696. }
  698. bool CMediaSource::SetAudioSrc(
  699. MediaType srcType,
  700. u_int8_t srcChannels,
  701. u_int32_t srcSampleRate)
  702. {
  703. // audio source info 
  704. m_audioSrcType = srcType;
  705. m_audioSrcChannels = srcChannels;
  706. m_audioSrcSampleRate = srcSampleRate;
  707. m_audioSrcSamplesPerFrame = 0; // unknown, presumed variable
  709. // init audio encoder
  710. delete m_audioEncoder;
  712. m_audioEncoder = AudioEncoderCreate(
  713. m_pConfig->GetStringValue(CONFIG_AUDIO_ENCODER));
  715. if (m_audioEncoder == NULL) {
  716. return false;
  717. }
  719. if (!m_audioEncoder->Init(m_pConfig, m_sourceRealTime)) {
  720. delete m_audioEncoder;
  721. m_audioEncoder = NULL;
  722. return false;
  723. }
  725. m_audioDstSamplesPerFrame = 
  726. m_audioEncoder->GetSamplesPerFrame();
  728. // if we need to resample
  729. if (m_audioDstSampleRate != m_audioSrcSampleRate) {
  731. // if sampling rates are integral multiples
  732. // we can use simpler, faster linear interpolation
  733. // else we use quadratic interpolation
  734. if (m_audioDstSampleRate < m_audioSrcSampleRate) {
  735. m_audioResampleUseLinear =
  736. ((m_audioSrcSampleRate % m_audioDstSampleRate) == 0);
  738. } else if (m_audioDstSampleRate >= m_audioSrcSampleRate) {
  739. m_audioResampleUseLinear =
  740. ((m_audioDstSampleRate % m_audioSrcSampleRate) == 0);
  741. }
  743. m_audioResampleInputNumber = 0;
  744. free(m_audioResampleInputBuffer);
  745. m_audioResampleInputBuffer =
  746. (int16_t*)calloc(16 * m_audioSrcChannels, 2);
  747. }
  749. m_audioPreEncodingBufferLength = 0;
  750. m_audioPreEncodingBufferMaxLength =
  751. 4 * DstSamplesToBytes(m_audioDstSamplesPerFrame);
  753. m_audioPreEncodingBuffer = (u_int8_t*)realloc(
  754. m_audioPreEncodingBuffer,
  755. m_audioPreEncodingBufferMaxLength);
  757. if (m_audioPreEncodingBuffer == NULL) {
  758. delete m_audioEncoder;
  759. m_audioEncoder = NULL;
  760. return false;
  761. }
  763. return true;
  764. }
  766. void CMediaSource::ProcessAudioFrame(
  767. u_int8_t* frameData,
  768. u_int32_t frameDataLength,
  769. Timestamp srcFrameTimestamp,
  770. bool resync)
  771. {
  772. if (m_videoSrcFrameNumber == 0 && m_audioSrcFrameNumber == 0) {
  773. m_startTimestamp = srcFrameTimestamp;
  774. }
  776. m_audioSrcFrameNumber++;
  777. m_audioSrcElapsedDuration = srcFrameTimestamp - m_startTimestamp;
  779. if (resync) {
  780. // flush preEncodingBuffer
  781. m_audioPreEncodingBufferLength = 0;
  783. // change dst sample numbers to account for gap
  784. m_audioDstSampleNumber =
  785. m_audioDstRawSampleNumber =
  786. DstTicksToSamples(m_audioSrcElapsedDuration);
  787. }
  789. bool pcmMalloced = false;
  790. bool pcmBuffered;
  791. u_int8_t* pcmData = frameData;
  792. u_int32_t pcmDataLength = frameDataLength;
  794. // resample audio, if necessary
  795. if (m_audioSrcSampleRate != m_audioDstSampleRate) {
  796. ResampleAudio(pcmData, pcmDataLength);
  798. // resampled data is now available in m_audioPreEncodingBuffer
  799. pcmBuffered = true;
  801. } else if (m_audioSrcSamplesPerFrame != m_audioDstSamplesPerFrame) {
  802. // reframe audio, if necessary
  803. // e.g. MP3 is 1152 samples/frame, AAC is 1024 samples/frame
  805. // add samples to end of m_audioBuffer
  806. // InitAudio() ensures that buffer is large enough
  807. memcpy(
  808. &m_audioPreEncodingBuffer[m_audioPreEncodingBufferLength],
  809. pcmData,
  810. pcmDataLength);
  812. m_audioPreEncodingBufferLength += pcmDataLength;
  814. pcmBuffered = true;
  816. } else {
  817. pcmBuffered = false;
  818. }
  820. // LATER restructure so as get rid of this label, and goto below
  821. pcmBufferCheck:
  823. if (pcmBuffered) {
  824. u_int32_t samplesAvailable =
  825. DstBytesToSamples(m_audioPreEncodingBufferLength);
  827. // not enough samples collected yet to call encode or forward
  828. if (samplesAvailable < m_audioDstSamplesPerFrame) {
  829. return;
  830. }
  832. // setup for encode/forward
  833. pcmData = 
  834. &m_audioPreEncodingBuffer[0];
  835. pcmDataLength = 
  836. DstSamplesToBytes(m_audioDstSamplesPerFrame);
  837. }
  839. // encode audio frame
  840. if (m_pConfig->m_audioEncode) {
  842. Timestamp encodingStartTimestamp = GetTimestamp();
  844. bool rc = m_audioEncoder->EncodeSamples(
  845. (u_int16_t*)pcmData, pcmDataLength);
  847. if (!rc) {
  848. debug_message("failed to encode audio");
  849. return;
  850. }
  852. Duration encodingTime =
  853. (GetTimestamp() - encodingStartTimestamp);
  855. if (m_sourceRealTime) {
  856. Duration drift = encodingTime 
  857. - DstSamplesToTicks(DstBytesToSamples(pcmDataLength));
  859. if (drift > 0) {
  860. m_videoSource->AddEncodingDrift(drift);
  861. }
  862. }
  864. u_int32_t forwardedSamples;
  865. u_int32_t forwardedFrames;
  867. ForwardEncodedAudioFrames(
  868. m_startTimestamp 
  869. + DstSamplesToTicks(m_audioDstSampleNumber),
  870. &forwardedSamples,
  871. &forwardedFrames);
  873. m_audioDstSampleNumber += forwardedSamples;
  874. m_audioDstFrameNumber += forwardedFrames;
  875. }
  877. // if desired, forward raw audio to sinks
  878. if (m_pConfig->SourceRawAudio()) {
  880. // make a copy of the pcm data if needed
  881. u_int8_t* pcmForwardedData;
  883. if (!pcmMalloced) {
  884. pcmForwardedData = (u_int8_t*)Malloc(pcmDataLength);
  885. memcpy(pcmForwardedData, pcmData, pcmDataLength);
  886. } else {
  887. pcmForwardedData = pcmData;
  888. pcmMalloced = false;
  889. }
  891. CMediaFrame* pFrame =
  892. new CMediaFrame(
  893. CMediaFrame::PcmAudioFrame, 
  894. pcmForwardedData, 
  895. pcmDataLength,
  896. m_startTimestamp 
  897. + DstSamplesToTicks(m_audioDstRawSampleNumber),
  898. DstBytesToSamples(pcmDataLength),
  899. m_audioDstSampleRate);
  900. ForwardFrame(pFrame);
  901. delete pFrame;
  903. m_audioDstRawSampleNumber += DstBytesToSamples(pcmDataLength);
  904. m_audioDstRawFrameNumber++;
  905. }
  907. if (pcmMalloced) {
  908. free(pcmData);
  909. }
  911. if (pcmBuffered) {
  912. m_audioPreEncodingBufferLength -= pcmDataLength;
  914. memcpy(
  915. &m_audioPreEncodingBuffer[0],
  916. &m_audioPreEncodingBuffer[pcmDataLength],
  917. m_audioPreEncodingBufferLength);
  919. goto pcmBufferCheck;
  920. }
  921. }
  923. void CMediaSource::ResampleAudio(
  924. u_int8_t* frameData,
  925. u_int32_t frameDataLength)
  926. {
  927. int16_t* pIn =
  928. (int16_t*)frameData;
  929. int16_t* pOut = 
  930. (int16_t*)&m_audioPreEncodingBuffer[m_audioPreEncodingBufferLength];
  932. // compute how many input samples are available
  933. u_int32_t numIn =
  934. m_audioResampleInputNumber + SrcBytesToSamples(frameDataLength);
  936. // compute how many output samples 
  937. // can be generated from the available input samples
  938. u_int32_t numOut =
  939. (numIn * m_audioDstSampleRate) / m_audioSrcSampleRate;
  941. float inTime0 = 
  942. (float)(m_audioResampleInputNumber * m_audioSrcSampleRate)
  943. / (float)m_audioDstSampleRate;
  945. int32_t inIndex;
  946. u_int32_t outIndex;
  948. // for all output samples
  949. for (outIndex = 0; true; outIndex++) {
  951. float outTime0 = 
  952. (outIndex * m_audioSrcSampleRate) / (float)m_audioDstSampleRate;
  954. inIndex = (int32_t)(outTime0 - inTime0 + 0.5);
  956. // DEBUG printf("resample out %d %f in %d %fn",
  957. // DEBUG outIndex, outTime0, inIndex, inTime0);
  959. // the unusual location of the loop exit condition
  960. // is because we need the initial inIndex for the next call
  961. // see the end of this function for how this is used
  962. if (outIndex >= numOut) {
  963. break;
  964. }
  966. float x1 = outTime0 - (inTime0 + inIndex);
  967. float x0 = x1 + 1;
  968. float x2 = x1 - 1;
  969. float x3 = x1 - 2;
  971. for (u_int8_t ch = 0; ch < m_audioSrcChannels; ch++) {
  972. int16_t y0, y1, y2, y3;
  974. if (inIndex < 0) {
  975. y1 = m_audioResampleInputBuffer
  976. [(-(inIndex) - 1) * m_audioSrcChannels + ch];
  977. } else {
  978. y1 = pIn[inIndex * m_audioSrcChannels + ch];
  979. }
  980. if (inIndex + 1 < 0) {
  981. y2 = m_audioResampleInputBuffer
  982. [(-(inIndex + 1) - 1) * m_audioSrcChannels + ch];
  983. } else {
  984. y2 = pIn[(inIndex + 1) * m_audioSrcChannels + ch];
  985. }
  987. if (m_audioResampleUseLinear) {
  988. *pOut++ = (int16_t)
  989. (((y2 * x1) - (y1 * x2)) + 0.5);
  991. } else { // use quadratic resampling
  992. if (inIndex - 1 < 0) {
  993. y0 = m_audioResampleInputBuffer
  994. [(-(inIndex - 1) - 1) * m_audioSrcChannels + ch];
  995. } else {
  996. y0 = pIn[(inIndex - 1) * m_audioSrcChannels + ch];
  997. }
  998. if (inIndex + 2 < 0) {
  999. y3 = m_audioResampleInputBuffer
  1000. [(-(inIndex + 2) - 1) * m_audioSrcChannels + ch];
  1001. } else {
  1002. y3 = pIn[(inIndex + 2) * m_audioSrcChannels + ch];
  1003. }
  1005. int32_t outValue = (int32_t)(
  1006. - (y0 * x1 * x2 * x3 / 6) 
  1007. + (y1 * x0 * x2 * x3 / 2) 
  1008. - (y2 * x0 * x1 * x3 / 2) 
  1009. + (y3 * x0 * x1 * x2 / 6)
  1010. + 0.5);
  1012. // DEBUG printf("x0 %f y %d %d %d %d -> %d (delta %d)n",
  1013. // DEBUG x0, y0, y1, y2, y3, 
  1014. // DEBUG outValue, outValue - ((y0 + y1) / 2));
  1016. if (outValue > 32767) {
  1017. outValue = 32767;
  1018. } else if (outValue < -32767) {
  1019. outValue = -32767;
  1020. }
  1022. *pOut++ = (int16_t)outValue;
  1023. }
  1024. }
  1025. }
  1027. // since resampling inputs can span input frame boundaries
  1028. // we may need to save up to 3 samples for the next call
  1029. m_audioResampleInputNumber = 0;
  1030. for (int32_t i = SrcBytesToSamples(frameDataLength) - 1; 
  1031.   i >= inIndex; i--) {
  1033. // DEBUG printf("resample save [%d] <- [%d]n",
  1034. // DEBUG m_audioResampleInputNumber, i);
  1036. memcpy(
  1037. &m_audioResampleInputBuffer[m_audioResampleInputNumber],
  1038. &pIn[i * m_audioSrcChannels],
  1039. m_audioSrcChannels * sizeof(int16_t));
  1041. m_audioResampleInputNumber++;
  1042. }
  1044. m_audioPreEncodingBufferLength += 
  1045. numOut * m_audioSrcChannels * sizeof(int16_t);
  1047. return;
  1048. }
  1050. void CMediaSource::ForwardEncodedAudioFrames(
  1051. Timestamp baseTimestamp,
  1052. u_int32_t* pNumSamples,
  1053. u_int32_t* pNumFrames)
  1054. {
  1055. u_int8_t* pFrame;
  1056. u_int32_t frameLength;
  1057. u_int32_t frameNumSamples;
  1059. (*pNumSamples) = 0;
  1060. (*pNumFrames) = 0;
  1062. while (m_audioEncoder->GetEncodedSamples(
  1063.   &pFrame, &frameLength, &frameNumSamples)) {
  1065. // sanity check
  1066. if (pFrame == NULL || frameLength == 0) {
  1067. break;
  1068. }
  1070. (*pNumSamples) += frameNumSamples;
  1071. (*pNumFrames)++;
  1073. // forward the encoded frame to sinks
  1074. CMediaFrame* pMediaFrame =
  1075. new CMediaFrame(
  1076. m_audioEncoder->GetFrameType(),
  1077. pFrame, 
  1078. frameLength,
  1079. baseTimestamp 
  1080. + DstSamplesToTicks((*pNumSamples)),
  1081. frameNumSamples,
  1082. m_audioDstSampleRate);
  1083. ForwardFrame(pMediaFrame);
  1084. delete pMediaFrame;
  1085. }
  1086. }
  1088. void CMediaSource::DoStopAudio()
  1089. {
  1090. if (m_audioEncoder) {
  1091. // flush remaining output from audio encoder
  1092. // and forward it to sinks
  1094. m_audioEncoder->EncodeSamples(NULL, 0);
  1096. u_int32_t forwardedSamples;
  1097. u_int32_t forwardedFrames;
  1099. ForwardEncodedAudioFrames(
  1100. m_startTimestamp
  1101. + DstSamplesToTicks(m_audioDstSampleNumber),
  1102. &forwardedSamples,
  1103. &forwardedFrames);
  1105. m_audioDstSampleNumber += forwardedSamples;
  1106. m_audioDstFrameNumber += forwardedFrames;
  1108. m_audioEncoder->Stop();
  1109. delete m_audioEncoder;
  1110. m_audioEncoder = NULL;
  1111. }
  1113. free(m_audioResampleInputBuffer);
  1114. m_audioResampleInputBuffer = NULL;
  1116. free(m_audioPreEncodingBuffer);
  1117. m_audioPreEncodingBuffer = NULL;
  1119. m_sourceAudio = false;
  1120. }