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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

video_v4l_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, 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"
  25. #include <sys/mman.h>
  27. #include "video_v4l_source.h"
  28. #include "video_util_rgb.h"
  31. int CV4LVideoSource::ThreadMain(void) 
  32. {
  33. while (true) {
  34. int rc;
  36. if (m_source) {
  37. rc = SDL_SemTryWait(m_myMsgQueueSemaphore);
  38. } else {
  39. rc = SDL_SemWait(m_myMsgQueueSemaphore);
  40. }
  42. // semaphore error
  43. if (rc == -1) {
  44. break;
  45. } 
  47. // message pending
  48. if (rc == 0) {
  49. CMsg* pMsg = m_myMsgQueue.get_message();
  51. if (pMsg != NULL) {
  52. switch (pMsg->get_value()) {
  53. case MSG_NODE_STOP_THREAD:
  54. DoStopCapture(); // ensure things get cleaned up
  55. delete pMsg;
  56. return 0;
  57. case MSG_NODE_START:
  58. case MSG_SOURCE_START_VIDEO:
  59. DoStartCapture();
  60. break;
  61. case MSG_NODE_STOP:
  62. DoStopCapture();
  63. break;
  64. case MSG_SOURCE_KEY_FRAME:
  65. DoGenerateKeyFrame();
  66. break;
  67. }
  69. delete pMsg;
  70. }
  71. }
  73. if (m_source) {
  74. try {
  75. ProcessVideo();
  76. }
  77. catch (...) {
  78. DoStopCapture();
  79. break;
  80. }
  81. }
  82. }
  84. return -1;
  85. }
  87. void CV4LVideoSource::DoStartCapture(void)
  88. {
  89. if (m_source) {
  90. return;
  91. }
  92. if (!Init()) {
  93. return;
  94. }
  96. m_source = true;
  97. }
  99. void CV4LVideoSource::DoStopCapture(void)
  100. {
  101. if (!m_source) {
  102. return;
  103. }
  105. DoStopVideo();
  107. ReleaseDevice();
  109. m_source = false;
  110. }
  112. bool CV4LVideoSource::Init(void)
  113. {
  114. if (!InitDevice()) {
  115. return false;
  116. }
  118. CalculateVideoFrameSize(m_pConfig);
  120. InitVideo(
  121. (m_pConfig->m_videoNeedRgbToYuv ?
  122. CMediaFrame::RgbVideoFrame :
  123. CMediaFrame::YuvVideoFrame),
  124. true);
  126. SetVideoSrcSize(
  127. m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH),
  128. m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT),
  129. m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH),
  130. true);
  132. m_maxPasses = (u_int8_t)(m_videoSrcFrameRate + 0.5);
  134. return true;
  135. }
  137. bool CV4LVideoSource::InitDevice(void)
  138. {
  139. int rc;
  140. char* deviceName = m_pConfig->GetStringValue(CONFIG_VIDEO_SOURCE_NAME);
  141. u_int16_t format;
  143. // open the video device
  144. m_videoDevice = open(deviceName, O_RDWR);
  145. if (m_videoDevice < 0) {
  146. error_message("Failed to open %s: %s", 
  147. deviceName, strerror(errno));
  148. return false;
  149. }
  151. // get device capabilities
  152. struct video_capability videoCapability;
  153. rc = ioctl(m_videoDevice, VIDIOCGCAP, &videoCapability);
  154. if (rc < 0) {
  155. error_message("Failed to get video capabilities for %s",
  156. deviceName);
  157. goto failure;
  158. }
  160. if (!(videoCapability.type & VID_TYPE_CAPTURE)) {
  161. error_message("Device %s is not capable of video capture!",
  162. deviceName);
  163. goto failure;
  164. }
  166. // N.B. "channel" here is really an input source
  167. struct video_channel videoChannel;
  168. videoChannel.channel = m_pConfig->GetIntegerValue(CONFIG_VIDEO_INPUT);
  169. rc = ioctl(m_videoDevice, VIDIOCGCHAN, &videoChannel);
  170. if (rc < 0) {
  171. error_message("Failed to get video channel info for %s",
  172. deviceName);
  173. goto failure;
  174. }
  176. // select video input and signal type
  177. videoChannel.norm = m_pConfig->GetIntegerValue(CONFIG_VIDEO_SIGNAL);
  178. rc = ioctl(m_videoDevice, VIDIOCSCHAN, &videoChannel);
  179. if (rc < 0) {
  180. error_message("Failed to set video channel info for %s",
  181. deviceName);
  182. goto failure;
  183. }
  184. if (m_pConfig->GetIntegerValue(CONFIG_VIDEO_SIGNAL) == VIDEO_MODE_NTSC) {
  185. m_videoSrcFrameRate = VIDEO_NTSC_FRAME_RATE;
  186. } else {
  187. m_videoSrcFrameRate = VIDEO_PAL_FRAME_RATE;
  188. }
  190. // input source has a TV tuner
  191. if (videoChannel.flags & VIDEO_VC_TUNER) {
  192. struct video_tuner videoTuner;
  194. // get tuner info
  195. if ((int32_t)m_pConfig->GetIntegerValue(CONFIG_VIDEO_TUNER) == -1) {
  196. m_pConfig->SetIntegerValue(CONFIG_VIDEO_TUNER, 0);
  197. }
  198. videoTuner.tuner = m_pConfig->GetIntegerValue(CONFIG_VIDEO_TUNER);
  199. rc = ioctl(m_videoDevice, VIDIOCGTUNER, &videoTuner);
  200. if (rc < 0) {
  201. error_message("Failed to get video tuner info for %s",
  202. deviceName);
  203. }
  205. // set tuner and signal type
  206. videoTuner.mode = m_pConfig->GetIntegerValue(CONFIG_VIDEO_SIGNAL);
  207. rc = ioctl(m_videoDevice, VIDIOCSTUNER, &videoTuner);
  208. if (rc < 0) {
  209. error_message("Failed to set video tuner info for %s",
  210. deviceName);
  211. }
  213. // tune in the desired frequency (channel)
  214. struct CHANNEL_LIST* pChannelList = ListOfChannelLists[
  215. m_pConfig->GetIntegerValue(CONFIG_VIDEO_SIGNAL)];
  216. struct CHANNEL* pChannel = pChannelList[
  217. m_pConfig->GetIntegerValue(CONFIG_VIDEO_CHANNEL_LIST_INDEX)].list;
  218. unsigned long videoFrequencyKHz = pChannel[
  219. m_pConfig->GetIntegerValue(CONFIG_VIDEO_CHANNEL_INDEX)].freq;
  220. unsigned long videoFrequencyTuner =
  221. ((videoFrequencyKHz / 1000) << 4) 
  222. | ((videoFrequencyKHz % 1000) >> 6);
  224. rc = ioctl(m_videoDevice, VIDIOCSFREQ, &videoFrequencyTuner);
  225. if (rc < 0) {
  226. error_message("Failed to set video tuner frequency for %s",
  227. deviceName);
  228. }
  229. }
  231. // get info on video capture buffers 
  232. rc = ioctl(m_videoDevice, VIDIOCGMBUF, &m_videoMbuf);
  233. if (rc < 0) {
  234. error_message("Failed to get video capture info for %s", 
  235. deviceName);
  236. goto failure;
  237. }
  239. // map the video capture buffers
  240. m_videoMap = mmap(0, m_videoMbuf.size, 
  241. PROT_READ | PROT_WRITE, MAP_SHARED, m_videoDevice, 0);
  242. if (m_videoMap == MAP_FAILED) {
  243. error_message("Failed to map video capture memory for %s", 
  244. deviceName);
  245. goto failure;
  246. }
  248. // allocate enough frame maps
  249. m_videoFrameMap = (struct video_mmap*)
  250. malloc(m_videoMbuf.frames * sizeof(struct video_mmap));
  251. if (m_videoFrameMap == NULL) {
  252. error_message("Failed to allocate enough memory"); 
  253. goto failure;
  254. }
  256. m_captureHead = 0;
  257. m_encodeHead = -1;
  258. format = VIDEO_PALETTE_YUV420P;
  260. for (int i = 0; i < m_videoMbuf.frames; i++) {
  261. // initialize frame map
  262. m_videoFrameMap[i].frame = i;
  263. m_videoFrameMap[i].width = 
  264. m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH);
  265. m_videoFrameMap[i].height = 
  266. m_pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT);
  267. m_videoFrameMap[i].format = format;
  269. // give frame to the video capture device
  270. rc = ioctl(m_videoDevice, VIDIOCMCAPTURE, &m_videoFrameMap[i]);
  271. if (rc < 0) {
  272. // try RGB24 palette instead
  273. if (i == 0 && format == VIDEO_PALETTE_YUV420P) {
  274. format = VIDEO_PALETTE_RGB24;
  275. i--;
  276. continue;
  277. } 
  279. error_message("Failed to allocate video capture buffer for %s", 
  280. deviceName);
  281. goto failure;
  282. }
  283. }
  285. if (format == VIDEO_PALETTE_RGB24) {
  286. m_pConfig->m_videoNeedRgbToYuv = true;
  287. }
  289. if (videoCapability.audios) {
  290. SetVideoAudioMute(false);
  291. }
  293. return true;
  295. failure:
  296. free(m_videoFrameMap);
  297. if (m_videoMap) {
  298. munmap(m_videoMap, m_videoMbuf.size);
  299. m_videoMap = NULL;
  300. }
  301. close(m_videoDevice);
  302. m_videoDevice = -1;
  303. return false;
  304. }
  306. void CV4LVideoSource::ReleaseDevice()
  307. {
  308. SetVideoAudioMute(true);
  310. // release device resources
  311. munmap(m_videoMap, m_videoMbuf.size);
  312. m_videoMap = NULL;
  314. close(m_videoDevice);
  315. m_videoDevice = -1;
  316. }
  318. void CV4LVideoSource::SetVideoAudioMute(bool mute)
  319. {
  320. if (!m_pConfig->m_videoCapabilities
  321.   || !m_pConfig->m_videoCapabilities->m_hasAudio) {
  322. return;
  323. }
  325. int rc;
  326. struct video_audio videoAudio;
  328. rc = ioctl(m_videoDevice, VIDIOCGAUDIO, &videoAudio);
  330. if (rc == 0 && (videoAudio.flags & VIDEO_AUDIO_MUTABLE)) {
  331. if (mute) {
  332. videoAudio.flags |= VIDEO_AUDIO_MUTE;
  333. } else {
  334. videoAudio.flags &= ~VIDEO_AUDIO_MUTE;
  335. }
  337. rc = ioctl(m_videoDevice, VIDIOCSAUDIO, &videoAudio);
  339. if (rc < 0) {
  340. debug_message("Can't set video audio for %s",
  341. m_pConfig->m_videoCapabilities->m_deviceName);
  342. }
  343. }
  344. }
  346. void CalculateVideoFrameSize(CLiveConfig* pConfig)
  347. {
  348. u_int16_t frameHeight;
  349. float aspectRatio = pConfig->GetFloatValue(CONFIG_VIDEO_ASPECT_RATIO);
  351. // crop video to appropriate aspect ratio modulo 16 pixels
  352. if ((aspectRatio - VIDEO_STD_ASPECT_RATIO) < 0.1) {
  353. frameHeight = pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT);
  354. } else {
  355. frameHeight = (u_int16_t)(
  356. (float)pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH) 
  357. / aspectRatio);
  359. if ((frameHeight % 16) != 0) {
  360. frameHeight += 16 - (frameHeight % 16);
  361. }
  363. if (frameHeight > pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT)) {
  364. // OPTION might be better to insert black lines 
  365. // to pad image but for now we crop down
  366. frameHeight = pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_HEIGHT);
  367. if ((frameHeight % 16) != 0) {
  368. frameHeight -= (frameHeight % 16);
  369. }
  370. }
  371. }
  373. pConfig->m_videoWidth = pConfig->GetIntegerValue(CONFIG_VIDEO_RAW_WIDTH);
  374. pConfig->m_videoHeight = frameHeight;
  376. pConfig->m_ySize = pConfig->m_videoWidth * pConfig->m_videoHeight;
  377. pConfig->m_uvSize = pConfig->m_ySize / 4;
  378. pConfig->m_yuvSize = (pConfig->m_ySize * 3) / 2;
  379. }
  381. int8_t CV4LVideoSource::AcquireFrame(void)
  382. {
  383. int rc;
  385. rc = ioctl(m_videoDevice, VIDIOCSYNC, &m_videoFrameMap[m_captureHead]);
  386. if (rc != 0) {
  387. return -1;
  388. }
  390. int8_t capturedFrame = m_captureHead;
  391. m_captureHead = (m_captureHead + 1) % m_videoMbuf.frames;
  393. if (m_captureHead == m_encodeHead) {
  394. debug_message("Video capture buffer overflow");
  395. return -1;
  396. }
  397. return capturedFrame;
  398. }
  400. void CV4LVideoSource::ProcessVideo(void)
  401. {
  402. // for efficiency, process ~1 second before returning to check for commands
  403. for (int pass = 0; pass < m_maxPasses; pass++) {
  405. // get next frame from video capture device
  406. m_encodeHead = AcquireFrame();
  407. if (m_encodeHead == -1) {
  408. continue;
  409. }
  411. Timestamp frameTimestamp = GetTimestamp();
  413. u_int8_t* mallocedYuvImage = NULL;
  414. u_int8_t* pY;
  415. u_int8_t* pU;
  416. u_int8_t* pV;
  418. // perform colorspace conversion if necessary
  419. if (m_videoSrcType == CMediaFrame::RgbVideoFrame) {
  420. mallocedYuvImage = (u_int8_t*)Malloc(m_videoSrcYUVSize);
  422. pY = mallocedYuvImage;
  423. pU = pY + m_videoSrcYSize;
  424. pV = pU + m_videoSrcUVSize,
  426. RGB2YUV(
  427. m_videoSrcWidth,
  428. m_videoSrcHeight,
  429. (u_int8_t*)m_videoMap + m_videoMbuf.offsets[m_encodeHead],
  430. pY,
  431. pU,
  432. pV,
  433. 1);
  434. } else {
  435. pY = (u_int8_t*)m_videoMap + m_videoMbuf.offsets[m_encodeHead];
  436. pU = pY + m_videoSrcYSize;
  437. pV = pU + m_videoSrcUVSize;
  438. }
  440. ProcessVideoYUVFrame(
  441. pY, 
  442. pU, 
  443. pV,
  444. m_videoSrcWidth,
  445. m_videoSrcWidth >> 1,
  446. frameTimestamp);
  448. // release video frame buffer back to video capture device
  449. if (ReleaseFrame(m_encodeHead)) {
  450. m_encodeHead = (m_encodeHead + 1) % m_videoMbuf.frames;
  451. } else {
  452. debug_message("Couldn't release capture buffer!");
  453. }
  455. free(mallocedYuvImage);
  456. }
  457. }
  459. bool CV4LVideoSource::InitialVideoProbe(CLiveConfig* pConfig)
  460. {
  461. static char* devices[] = {
  462. "/dev/video", 
  463. "/dev/video0", 
  464. "/dev/video1", 
  465. "/dev/video2", 
  466. "/dev/video3"
  467. };
  468. char* deviceName = pConfig->GetStringValue(CONFIG_VIDEO_SOURCE_NAME);
  469. CVideoCapabilities* pVideoCaps;
  471. // first try the device we're configured with
  472. pVideoCaps = new CVideoCapabilities(deviceName);
  474. if (pVideoCaps->IsValid()) {
  475. pConfig->m_videoCapabilities = pVideoCaps;
  476. return true;
  477. }
  479. delete pVideoCaps;
  481. // no luck, go searching
  482. for (u_int32_t i = 0; i < sizeof(devices) / sizeof(char*); i++) {
  484. // don't waste time trying something that's already failed
  485. if (!strcmp(devices[i], deviceName)) {
  486. continue;
  487. } 
  489. pVideoCaps = new CVideoCapabilities(devices[i]);
  491. if (pVideoCaps->IsValid()) {
  492. pConfig->SetStringValue(CONFIG_VIDEO_SOURCE_NAME, devices[i]);
  493. pConfig->m_videoCapabilities = pVideoCaps;
  494. return true;
  495. }
  497. delete pVideoCaps;
  498. }
  500. return false;
  501. }
  503. bool CVideoCapabilities::ProbeDevice()
  504. {
  505. int rc;
  507. int videoDevice = open(m_deviceName, O_RDWR);
  508. if (videoDevice < 0) {
  509. return false;
  510. }
  511. m_canOpen = true;
  513. // get device capabilities
  514. struct video_capability videoCapability;
  515. rc = ioctl(videoDevice, VIDIOCGCAP, &videoCapability);
  516. if (rc < 0) {
  517. debug_message("Failed to get video capabilities for %s", m_deviceName);
  518. m_canCapture = false;
  519. close(videoDevice);
  520. return false;
  521. }
  523. if (!(videoCapability.type & VID_TYPE_CAPTURE)) {
  524. debug_message("Device %s is not capable of video capture!", 
  525. m_deviceName);
  526. m_canCapture = false;
  527. close(videoDevice);
  528. return false;
  529. }
  530. m_canCapture = true;
  532. m_driverName = stralloc(videoCapability.name);
  533. m_numInputs = videoCapability.channels;
  535. m_minWidth = videoCapability.minwidth;
  536. m_minHeight = videoCapability.minheight;
  537. m_maxWidth = videoCapability.maxwidth;
  538. m_maxHeight = videoCapability.maxheight;
  540. m_hasAudio = videoCapability.audios;
  542. m_inputNames = (char**)malloc(m_numInputs * sizeof(char*));
  543. memset(m_inputNames, 0, m_numInputs * sizeof(char*));
  545. m_inputSignalTypes = (u_int8_t*)malloc(m_numInputs * sizeof(u_int8_t));
  546. memset(m_inputSignalTypes, 0, m_numInputs * sizeof(u_int8_t));
  548. m_inputHasTuners = (bool*)malloc(m_numInputs * sizeof(bool));
  549. memset(m_inputHasTuners, 0, m_numInputs * sizeof(bool));
  551. m_inputTunerSignalTypes = (u_int8_t*)malloc(m_numInputs * sizeof(u_int8_t));
  552. memset(m_inputTunerSignalTypes, 0, m_numInputs * sizeof(u_int8_t));
  555. for (int i = 0; i < m_numInputs; i++) {
  556. // N.B. "channel" here is really an input source
  557. struct video_channel videoChannel;
  558. videoChannel.channel = i;
  559. rc = ioctl(videoDevice, VIDIOCGCHAN, &videoChannel);
  560. if (rc < 0) {
  561. debug_message("Failed to get video channel info for %s:%u",
  562. m_deviceName, i);
  563. continue;
  564. }
  565. m_inputNames[i] = stralloc(videoChannel.name);
  566. m_inputSignalTypes[i] = videoChannel.norm;
  568. if (videoChannel.flags & VIDEO_VC_TUNER) {
  569. // ignore videoChannel.tuners for now
  570. // current bt drivers only support 1 tuner per input port
  572. struct video_tuner videoTuner;
  573. videoTuner.tuner = 0;
  574. rc = ioctl(videoDevice, VIDIOCGTUNER, &videoTuner);
  575. if (rc < 0) {
  576. debug_message("Failed to get video tuner info for %s:%u",
  577. m_deviceName, i);
  578. continue;
  579. }
  581. m_inputHasTuners[i] = true;
  582. m_inputTunerSignalTypes[i] = videoTuner.flags & 0x7;
  583. }
  584. }
  586. close(videoDevice);
  587. return true;
  588. }