久久国产成人av_抖音国产毛片_a片网站免费观看_A片无码播放手机在线观看,色五月在线观看,亚洲精品m在线观看,女人自慰的免费网址,悠悠在线观看精品视频,一级日本片免费的,亚洲精品久,国产精品成人久久久久久久

搜索
分享

linux下面如何用ffmpeg將h264幀數(shù)據(jù)村存為FLV文件！,！

 dwlinux 2014-04-05
最近一段時間一直在研究怎么將接收到的H264幀數(shù)據(jù),，存為一個FLV文件，初步的想法是用ffmpeg提供的開源庫來實現(xiàn),，但因為之前一直沒接觸過這個,，具體怎么做還是一籌莫展，各位前輩有沒有之前做過這個
的,，提供一些經(jīng)驗唄?。。?br>
或者不用ffmpeg,，有別的方案也行,，但在轉換效率以及穩(wěn)定性上要求很高，因為這是服務器上要做的功能,，而且數(shù)據(jù)量會特別龐大,。。,。,。。

Rank: 7Rank: 7Rank: 7

帖子
3349
主題
256
精華
2
可用積分
17557
專家積分
40
在線時間
3586 小時
注冊時間
2005-09-14
最后登錄
2014-04-04
論壇徽章:
1
未羊 日期:2013-12-16 12:45:46
2樓 [報告]
發(fā)表于 2011-10-19 10:18:00 |只看該作者
靠,， 這個我作過,， FLV 的文件格式非常簡單， 直接找 adobe 的說明,， 照著寫就行了
授我以魚,， 不要授我以漁

找工作，  linux 系統(tǒng)編程,， 服務器編程
30K 左右

帖子
12
主題
2
精華
0
可用積分
27
專家積分
0
在線時間
67 小時
注冊時間
2011-08-24
最后登錄
2014-03-12
論壇徽章:
0
3樓 [報告]
發(fā)表于 2011-10-19 10:52:26 |只看該作者
是不是直接就拿H264的幀往flv的tag里面放,，然后那些header自己根據(jù)幀的信息去構造?。?！照這么說,，ffmpeg豈不根本用不到了啊?。,。?/td>

Rank: 1

帖子
1321
主題
81
精華
0
可用積分
502
專家積分
10
在線時間
2030 小時
注冊時間
2008-07-16
最后登錄
2014-03-10
論壇徽章:
0
4樓 [報告]
發(fā)表于 2011-10-19 10:52:45 |只看該作者
小書僮

Rank: 3Rank: 3

帖子
393
主題
12
精華
0
可用積分
2067
專家積分
0
在線時間
1665 小時
注冊時間
2009-03-30
最后登錄
2013-11-29
論壇徽章:
0
5樓 [報告]
發(fā)表于 2011-10-19 10:56:56 |只看該作者
一個是壓縮算法,，一個是存儲格式,。你要是只保持成文件，按格式存就是了,。
不解碼的話,，應該不涉及ffmpeg。
強身健體

Rank: 7Rank: 7Rank: 7

帖子
3349
主題
256
精華
2
可用積分
17557
專家積分
40
在線時間
3586 小時
注冊時間
2005-09-14
最后登錄
2014-04-04
論壇徽章:
1
未羊 日期:2013-12-16 12:45:46
6樓 [報告]
發(fā)表于 2011-10-19 11:07:52 |只看該作者
本帖最后由 zylthinking 于 2011-10-19 11:08 編輯

那我也不賣漁了,， 摘些代碼
  1. static char* g_lastKeyFrame = NULL;
  2. static int g_keyfrm_buf = 0;
  3. static int g_keyfrm_len = 0;

  5. int FlvSaveKeyFrame(void* data, int len){
  6.     if(len > g_keyfrm_buf){
  7.         free(g_lastKeyFrame);
  8.         g_lastKeyFrame = (char *) malloc(len);
  9.         if(g_lastKeyFrame == NULL){
  10.             g_keyfrm_len = 0;
  11.             return -1;
  12.         }
  13.         g_keyfrm_buf = len;
  14.     }

  16.     g_keyfrm_len = len;
  17.     if(len > 0){
  18.         memcpy(g_lastKeyFrame, data, g_keyfrm_len);
  19.     }
  20.     return 0;
  21. }

  23. int FlvGetLastKeyFrame(char*& buf){
  24.     buf = g_lastKeyFrame;
  25.     return g_keyfrm_len;
  26. }

  28. static char* g_sps_buf = NULL;
  29. static int g_sps_buf_len = 0;
  30. static int g_sps_len = 0;

  32. int FlvSaveSpsFrame(void* data, int len){
  33.     if(len > g_sps_buf_len){
  34.         free(g_sps_buf);
  35.         g_sps_buf = (char *) malloc(len);
  36.         if(g_sps_buf == NULL){
  37.             g_sps_buf_len = 0;
  38.             return -1;
  39.         }
  40.         g_sps_buf_len = len;
  41.     }

  43.     g_sps_len = len;
  44.     if(len > 0){
  45.         memcpy(g_sps_buf, data, g_sps_len);
  46.     }
  47.     return 0;
  48. }

  50. int FlvGetSpsFrame(char*& buf){
  51.     buf = g_sps_buf;
  52.     return g_sps_len;
  53. }

  55. static char* g_aac_buf = NULL;
  56. static int g_aac_buf_len = 0;
  57. static int g_aac_len = 0;

  59. int FlvSaveAacFrame(void* data, int len){
  60.     if(len > g_aac_buf_len){
  61.         free(g_aac_buf);
  62.         g_aac_buf = (char *) malloc(len);
  63.         if(g_aac_buf == NULL){
  64.             g_aac_buf_len = 0;
  65.             return -1;
  66.         }
  67.         g_aac_buf_len = len;
  68.     }

  70.     g_aac_len = len;
  71.     if(len > 0){
  72.         memcpy(g_aac_buf, data, g_aac_len);
  73.     }
  74.     return 0;
  75. }

  77. int FlvGetAacFrame(char*& buf){
  78.     buf = g_aac_buf;
  79.     return g_aac_len;
  80. }

  82. typedef int (*type_parser)(const char* flv_buffer, media_info& info);
  83. struct flv_media_parser{
  84.     DWORD fourcc;
  85.     type_parser parser;
  86. };

  88. //=========================================================

  90. // stupid compiler
  91. static void my_free(void* addr){
  92.     free(addr);
  93. }

  95. static int h264_parser(const char* flv_buffer, media_info& info){
  96.     info.bit_count = 0;
  97.     info.extra = 1;

  99.     int byte1 = ((int) flv_buffer[1]) & 0xff;
  100.     int byte2 = ((int) flv_buffer[2]) & 0xff;
  101.     int byte3 = ((int) flv_buffer[3]) & 0xff;
  102.     DWORD len = (byte1 << 16) | (byte2 << 8) | byte3;

  104.     int byte4 = ((int) flv_buffer[4]) & 0xff;
  105.     int byte5 = ((int) flv_buffer[5]) & 0xff;
  106.     int byte6 = ((int) flv_buffer[6]) & 0xff;
  107.     int byte7 = ((int) flv_buffer[7]) & 0xff;
  108.     int byte13 =  ((int) flv_buffer[13]) & 0xff;
  109.     int byte14 =  ((int) flv_buffer[14]) & 0xff;
  110.     int byte15 =  ((int) flv_buffer[15]) & 0xff;

  112.     info.dts = (byte7 << 24) | (byte4 << 16) | (byte5 << 8) | byte6;
  113.     int offset = (byte13 << 16) | (byte14 << 8) | byte15;
  114.     info.pts = info.dts + offset;

  116.     int byte12 = ((int) flv_buffer[12]) & 0xff;
  117.     if(byte12 == 0){
  118.         int sps_len = 0;
  119.         int pps_len = 0;
  120.         const char* sps = NULL;
  121.         const char* pps = NULL;

  123.         int nr_sps = ((int) flv_buffer[21]) & 0x1f;
  124.         if(nr_sps == 1){
  125.             int byte22 = ((int) flv_buffer[22]) & 0xff;
  126.             int byte23 = ((int) flv_buffer[23]) & 0xff;
  127.             sps_len = (byte22 << 8) | byte23;
  128.             sps = &flv_buffer[24];
  129.             pps = sps + sps_len;
  130.             sps_len += 4;
  131.         }else{
  132.             // no more than 1 sps currently
  133.             assert(nr_sps == 0);
  134.         }

  136.         int nr_pps = pps[0] & 0xff;
  137.         if(nr_pps == 1){
  138.             int byte1 = ((int) pps[1]) & 0xff;
  139.             int byte2 = ((int) pps[2]) & 0xff;
  140.             pps_len = ((byte1 << 8) | byte2) + 4;
  141.             pps = &pps[3];
  142.         }else{
  143.             pps = NULL;
  144.             // no more than 1 pps currently
  145.             assert(nr_pps == 0);
  146.         }

  148.         int header_len = sps_len + pps_len;
  149.         assert(header_len > 0);
  150.         unsigned char* buffer = (unsigned char *) malloc(header_len);
  151.         if(buffer == NULL){
  152.             return -1;
  153.         }

  155.         info.free = my_free;
  156.         info.length = header_len;
  157.         info.buffer = (char *) buffer;

  159.         if(sps_len > 0){
  160.             sps_len -= 4;

  162.             buffer[0] = sps_len >> 24;
  163.             buffer[1] = sps_len >> 16;
  164.             buffer[2] = sps_len >> 8;
  165.             buffer[3] = sps_len;
  166.             buffer += 4;
  167.             memcpy(buffer, sps, sps_len);
  168.             buffer += sps_len;
  169.         }

  171.         if(pps_len > 0){
  172.             pps_len -= 4;

  174.             buffer[0] = pps_len >> 24;
  175.             buffer[1] = pps_len >> 16;
  176.             buffer[2] = pps_len >> 8;
  177.             buffer[3] = pps_len;
  178.             buffer += 4;
  179.             memcpy(buffer, pps, pps_len);
  180.             buffer += pps_len;
  181.         }

  183.         return len + 11 + 4;
  184.     }else if(byte12 == 1){
  185.         info.length = len - 5;
  186.         info.buffer = (char *) &flv_buffer[16];
  187.         return len + 11 + 4;
  188.     }
  189.     return -1;
  190. }

  192. static flv_media_parser flv_h264_parser = {
  193.     make_fourcc('H', '2', '6', '4'),
  194.     h264_parser
  195. };

  197. static flv_media_parser* video_parser_of(char codec_id){
  198.     if(codec_id == (char) 0x07){
  199.         return &flv_h264_parser;
  200.     }
  201.     return NULL;
  202. }

  204. static int flv_video_unpack(const char* flv_buffer, media_info& info){
  205.     char byte11 = flv_buffer[11] & 0xff;
  206.     BOOL key_frame = (0x10 == (byte11 & 0xf0));
  207.     int codec_id = (byte11 & 0x0f);

  209.     flv_media_parser* parser = video_parser_of(codec_id);
  210.     if(parser == NULL){
  211.         return -1;
  212.     }

  214.     info.fourcc = parser->fourcc;
  215.     return parser->parser(flv_buffer, info);
  216. }

  218. //=========================================================

  220. static char adts[7] = {0xff, 0xf1};

  222. static int aac_parser(const char* flv_buffer, media_info& info){
  223.     int byte1 = ((int) flv_buffer[1]) & 0xff;
  224.     int byte2 = ((int) flv_buffer[2]) & 0xff;
  225.     int byte3 = ((int) flv_buffer[3]) & 0xff;
  226.     DWORD len = (byte1 << 16) | (byte2 << 8) | byte3;

  228.     int byte4 = ((int) flv_buffer[4]) & 0xff;
  229.     int byte5 = ((int) flv_buffer[5]) & 0xff;
  230.     int byte6 = ((int) flv_buffer[6]) & 0xff;
  231.     int byte7 = ((int) flv_buffer[7]) & 0xff;

  233.     info.dts = (byte7 << 24) | (byte4 << 16) | (byte5 << 8) | byte6;
  234.     info.pts = info.dts;

  236.     // flash only support 44k, 16bits aac
  237.     info.sample_rate = 44100;
  238.     info.bit_count = 16;
  239.     info.chans = (flv_buffer[11] & 0x01) ? 2 : 1;
  240.    
  241.     int type = ((int) flv_buffer[12]) & 0xff;
  242.     if(type == 0){
  243.         int byte13 = ((int) flv_buffer[13]) & 0xff;
  244.         int objType = ((byte13 & 0xf1) >> 3) - 1;

  246.         int byte14 = ((int) flv_buffer[14]) & 0xff;
  247.         int samplerate_indx = ((byte13 & 0x7) << 1 | (byte14 & 0x80) >> 7);
  248.         int chans = (byte14 & 0x71) >> 3;
  249.         // format of flash
  250.         assert(chans == 2 && samplerate_indx == 7);

  252.         adts[2] = (objType << 6) | (samplerate_indx << 2) | ((chans & 0x04) >> 2);
  253.         adts[3] = ((chans & 0x03) << 6);

  255.         return len + 11 + 4;
  256.     }else if(type == 1){
  257.         if(adts[2] == 0){
  258.             cs << "drop audio data, because of header is missing" << endl;
  259.             goto LABEL;
  260.         }
  261.         const static int adts_len = sizeof(adts);
  262.         info.length = len - 2 + adts_len;

  264.         info.buffer = (char *) malloc(info.length);
  265.         if(info.buffer == NULL){
  266.             return -1;
  267.         }
  268.         info.free = my_free;

  270.         assert(sizeof(int) == 4);
  271.         *((int *) &info.buffer[0]) = *((int *) &adts[0]);

  273.         info.buffer[3] |= (info.length & 0x1fff) >> 11;
  274.         info.buffer[4] = (info.length & 0x7ff) >> 3;
  275.         info.buffer[5] = (info.length & 0x07) << 5;
  276.         info.buffer[5] |= 0x1f;
  277.         info.buffer[6] = 0xfc;
  278.         memcpy((void *) &info.buffer[adts_len], &flv_buffer[13], len - 2);
  279. LABEL:
  280.         return len + 11 + 4;
  281.     }
  282.     return -1;
  283. }

  285. static flv_media_parser flv_aac_parser = {
  286.     mpeg4_aac,
  287.     aac_parser
  288. };

  290. static flv_media_parser* audio_parser_of(char codec_id){
  291.     if(codec_id == (char) 0xa0){
  292.         return &flv_aac_parser;
  293.     }
  294.     return NULL;
  295. }

  297. static int flv_audio_unpack(const char* flv_buffer, media_info& info){
  298.     char byte11 = flv_buffer[11] & 0xff;
  299.     char fmt = byte11 & 0xf0;

  301.     flv_media_parser* parser = audio_parser_of(fmt);
  302.     if(parser == NULL){
  303.         return -1;
  304.     }

  306.     info.fourcc = parser->fourcc;
  307.     return parser->parser(flv_buffer, info);
  308. }

  310. //=========================================================

  312. int FlvUnpack(const char* flv_buffer, media_info& info){
  313.     info.free = NULL;
  314.     info.buffer = NULL;
  315.     info.length = 0;

  317.     int n = -1;
  318.     char audio_or_video = flv_buffer[0];
  319.     if(audio_or_video == 0x09){
  320.         n = flv_video_unpack(flv_buffer, info);

  322.         if(n != -1){
  323.             if(FlvIsSpsFrame((BYTE *) flv_buffer, n)){
  324.                 FlvSaveSpsFrame((void *) flv_buffer, n);
  325.             }else if(FlvIsKeyFrame((BYTE *) flv_buffer, n)){
  326.                 FlvSaveKeyFrame((void *) flv_buffer, n);
  327.             }
  328.         }
  329.     }
  330.    
  331.     if(audio_or_video == 0x08){
  332.         n = flv_audio_unpack(flv_buffer,info);
  333.         if(n != -1){
  334.             if(FlvIsAacHeaderFrame((BYTE *) flv_buffer, n)){
  335.                 FlvSaveAacFrame((void *) flv_buffer, n);
  336.             }
  337.         }
  338.     }

  340.     return n;
  341. }

  343. BOOL FlvIsKeyFrame(BYTE* flv_buffer, int len){
  344.     if(len < 12 || flv_buffer[0] != 0x09){
  345.         return FALSE;
  346.     }
  347.         return (0x10 == (flv_buffer[11] & 0xf0));
  348. }

  350. BOOL FlvIsSpsFrame(BYTE* flv_buffer, int len){
  351.     if(len < 13 || flv_buffer[0] != 0x09){
  352.         return FALSE;
  353.     }
  354.         return (0 == (flv_buffer[12]));
  355. }

  357. BOOL FlvIsAacHeaderFrame(BYTE* flv_buffer, int len){
  358.     if(len < 13 || flv_buffer[0] != 0x08){
  359.         return FALSE;
  360.     }
  361.         return (0 == (flv_buffer[12]));
  362. }

  364. int FlvFrameLength(BYTE* flv_buffer, int len){
  365.     if(len < 4){
  366.         return -1;
  367.     }

  369.     int byte1 = ((int) flv_buffer[1]) & 0xff;
  370.     int byte2 = ((int) flv_buffer[2]) & 0xff;
  371.     int byte3 = ((int) flv_buffer[3]) & 0xff;
  372.     int length = (byte1 << 16) | (byte2 << 8) | byte3;

  374.     length += 11 + 4;
  375.     if(length <= len){
  376.         return length;
  377.     }
  378.     return -1;
  379. }

  381. DWORD FlvGetDts(BYTE* flv_buffer, int len){
  382.     if(len < 8){
  383.         return (DWORD) (-1);
  384.     }
  385.     int byte4 = ((int) flv_buffer[4]) & 0xff;
  386.     int byte5 = ((int) flv_buffer[5]) & 0xff;
  387.     int byte6 = ((int) flv_buffer[6]) & 0xff;
  388.     int byte7 = ((int) flv_buffer[7]) & 0xff;

  390.    DWORD st = (byte7 << 24) | (byte4 << 16) | (byte5 << 8) | byte6;
  391.    return st;
  392. }

  394. void FlvSetDts(UINT32 ts, void* buf, int len, BOOL zeroOffset){
  395.     int left = len;
  396.     char* pch = (char *) buf;
  397.     while(left > 0){
  398.         int n1 = pch[1] & 0xff;
  399.         int n2 = pch[2] & 0xff;
  400.         int n3 = pch[3] & 0xff;
  401.         int n = (n1 << 16) | (n2 << 8) | n3;

  403.         *((char*)pch + 4) = (unsigned char) (ts >> 16);
  404.             *((char*)pch + 5) = (unsigned char) (ts >> 8);
  405.             *((char*)pch + 6) = (unsigned char) ts;
  406.             *((char*)pch + 7) = (unsigned char) (ts >> 24);

  408.         if(zeroOffset){
  409.                 *((char*)pch + 13) = 0;
  410.                 *((char*)pch + 14) = 0;
  411.                 *((char*)pch + 15) = 0;
  412.         }
  413.         
  414.         pch += (n + 11 + 4);
  415.         left -= (n + 11 + 4);
  416.     }
  417.     assert(left == 0);
  418. }

  420. int FlvMediaType(const char* flv_buffer, int len){
  421.     if(len < 1){
  422.         goto LABEL;
  423.     }

  425.     if(flv_buffer[0] == 0x09){
  426.         return media_video;
  427.     }else if(flv_buffer[0] == 0x08){
  428.         return media_audio;
  429.     }
  430. LABEL:
  431.     assert(false);
  432.     return media_none;
  433. }

  435. int FlvTagBytes(int* head, int* tail){
  436.     if(head) *head = 11;
  437.     if(tail) *tail = 4;
  438.     return 15;
  439. }



  443. const static BYTE hdrflvout[] = {
  444.     0x46,0x4C,0x56,0x01,0x05,0x00,0x00,0x00,0x09,
  445.     0x00,0x00,0x00,0x00,
  446. };

  448. CFlvWrite::CFlvWrite(void){
  449.         m_bOk = FALSE;
  450.         m_hFile = NULL;
  451.     m_need_sps = TRUE;
  452.     m_need_kfrm = TRUE;
  453.     m_need_aach = TRUE;
  454.     m_base_tick_video = 0;
  455.     m_base_tick_audio = 0;
  456. }

  458. CFlvWrite::~CFlvWrite(void){
  459.         Close();
  460. }

  462. HRESULT CFlvWrite::Open(LPCTSTR szOutName, LPCTSTR szExtParam){
  463.         if(m_bOk)
  464.                 return S_OK;  //已經(jīng)打開
  465.         m_bOk = FALSE;

  467.         m_hFile = _tfopen(szOutName, _T("wb"));
  468.         if( m_hFile <= 0)
  469.                 return E_FAIL;
  470.     fwrite(hdrflvout, sizeof(hdrflvout), 1, m_hFile);

  472.         m_bOk = TRUE;
  473.         return S_OK;
  474. }

  476. HRESULT CFlvWrite::Write(BYTE* ppData, int nLen){
  477.         SingleLock l(m_cs);
  478.     if(!m_bOk){
  479.                 return E_FAIL;
  480.     }

  482.     if(m_hFile == NULL){
  483.         ASSERT(FALSE);     
  484.         return E_FAIL;
  485.     }

  487.     int sps_len = 0;
  488.     char* sps_buf;
  489.     if(m_need_sps){
  490.         sps_len = FlvGetSpsFrame(sps_buf);
  491.     }

  493.     int keyframe_len = 0;
  494.     char* kfrm_buf;
  495.     if(m_need_kfrm){
  496.         keyframe_len = FlvGetLastKeyFrame(kfrm_buf);
  497.     }

  499.     int aac_len = 0;
  500.     char* aac_buf;
  501.     if(m_need_aach){
  502.         aac_len = FlvGetAacFrame(aac_buf);
  503.     }

  505.     while(nLen > 0){
  506.         int len = FlvFrameLength(ppData, nLen);
  507.         ASSERT(len != -1);

  509.         int type = FlvMediaType((const char *) ppData, len);
  510.         ASSERT(type != media_none);

  512.         if(type == media_audio){
  513.             if(m_need_aach){
  514.                 BOOL aach = FlvIsAacHeaderFrame(ppData, len);
  515.                 if(aach){
  516.                     m_need_aach = FALSE;
  517.                     FlvSetDts(0, ppData, len, FALSE);
  518.                     fwrite(ppData, 1, len, m_hFile);
  519.                     goto LABEL;
  520.                 }else if(aac_len){
  521.                     FlvSetDts(0, aac_buf, aac_len, FALSE);
  522.                     fwrite(aac_buf, 1, aac_len, m_hFile);
  523.                     m_need_aach = FALSE;
  524.                 }else{
  525.                     goto LABEL;
  526.                 }
  527.             }

  529.             ASSERT(!m_need_aach);
  530.             DWORD ts = FlvGetDts(ppData, len);
  531.             if(m_base_tick_audio == 0){
  532.                 m_base_tick_audio = ts;
  533.             }

  535.             FlvSetDts(ts - m_base_tick_audio, ppData, len, FALSE);
  536.             fwrite(ppData, 1, len, m_hFile);
  537.         }else{
  538.             BOOL sps = FlvIsSpsFrame(ppData, len);
  539.             if(sps){
  540.                 FlvSetDts(0, ppData, len, TRUE);
  541.                 fwrite(ppData, 1, len, m_hFile);
  542.                 m_need_sps = FALSE;
  543.                 goto LABEL;
  544.             }
  545.             
  546.             if(m_need_sps){
  547.                 if(sps_len == 0){
  548.                     goto LABEL;
  549.                 }
  550.                 FlvSetDts(0, sps_buf, sps_len, TRUE);
  551.                 fwrite(sps_buf, 1, sps_len, m_hFile);
  552.                 m_need_sps = FALSE;
  553.             }

  555.             DWORD ts = FlvGetDts(ppData, len);
  556.             if(m_base_tick_video == 0){
  557.                 m_base_tick_video = ts;
  558.             }

  560.             if(FlvIsKeyFrame(ppData, len)){
  561.                 m_need_kfrm = FALSE;
  562.             }else if(m_need_kfrm){
  563.                 if(keyframe_len == 0){
  564.                     goto LABEL;
  565.                 }

  567.                 FlvSetDts(0, kfrm_buf, keyframe_len, TRUE);
  568.                 fwrite(kfrm_buf, 1, keyframe_len, m_hFile);
  569.                 m_need_kfrm = FALSE;
  570.             }

  572.             FlvSetDts(ts - m_base_tick_video, ppData, len, FALSE);
  573.             fwrite(ppData, 1, len, m_hFile);
  574.         }
  575. LABEL:
  576.         ppData += len;
  577.         nLen -= len;
  578.     }

  580.     return S_OK;
  581. }


  584. HRESULT CFlvWrite::Close(){
  585.     if(m_hFile){
  586.                 fclose(m_hFile);
  587.     }

  589.     m_base_tick_video = m_base_tick_audio = 0;
  590.     m_need_aach = m_need_sps = m_need_kfrm = TRUE;
  591.         m_hFile = NULL;
  592.         m_bOk = FALSE;
  593.         return S_OK;
  594. }
復制代碼
授我以魚,， 不要授我以漁

找工作,，  linux 系統(tǒng)編程,， 服務器編程
30K 左右

Rank: 5Rank: 5

帖子
3748
主題
583
精華
0
可用積分
7912
專家積分
0
在線時間
2409 小時
注冊時間
2008-08-15
最后登錄
2013-09-19
論壇徽章:
0
7樓 [報告]
發(fā)表于 2011-10-19 11:12:07 |只看該作者
貌似能實現(xiàn)無限長度的視頻會議,！Great,！我需要！

帖子
12
主題
2
精華
0
可用積分
27
專家積分
0
在線時間
67 小時
注冊時間
2011-08-24
最后登錄
2014-03-12
論壇徽章:
0
8樓 [報告]
發(fā)表于 2011-10-19 11:51:46 |只看該作者
感謝各位,，我們公司就是做網(wǎng)絡會議的，不過我正在做的是會后的一個附加功能,，提供會議的錄制，要求對于會

中當中的視頻數(shù)據(jù),，音頻數(shù)據(jù)等,。最后全部整合成一個文件,，支持會后回放,。我也就是一個新手，今年剛畢業(yè)

的,，在這邊也基本上給前輩打打下手,，以后不懂得地方還得請各位多多關照！?。?/td>

    本站是提供個人知識管理的網(wǎng)絡存儲空間，所有內(nèi)容均由用戶發(fā)布,，不代表本站觀點。請注意甄別內(nèi)容中的聯(lián)系方式,、誘導購買等信息，謹防詐騙,。如發(fā)現(xiàn)有害或侵權內(nèi)容，請點擊一鍵舉報,。
    轉藏 分享 獻花（0）

    0條評論

    發(fā)表

    請遵守用戶 評論公約

    類似文章 更多