xiahua882
xiahua882

live555转发DVB实时流（TS流）数据

 最近在做一个关于流媒体的项目，其需求简单描述就是把DVB上播放的电视内容，通过流媒体服务器发送到局域网上，使用户可以在手机或者PC端观看电视节目。

    虽然从网上知道Live555并不是最好的流媒体解决方案，但是想快速出Demo的话，Live555还算是一个不错的选择。之前介绍了Live555的移植，这里就不再赘述。

    闲话没有，直接捞干的。

    一、Live555需要修改的内容

    Live555需要修改的内容主要是两个方面：

    1）Source

    2）MediaSubsession

    因为从DVB上读取到的是TS格式的数据流，所以我们参考TS文件的代码。参考的两个类及其在Live555中的继承关系分别是：

    1）ByteStreamFileSource

live555转发DVB实时流（TS流）数据_第1张图片

    2）MPEG2TransportFileServerMediaSubsession

live555转发DVB实时流（TS流）数据_第2张图片

二、新创建的类及继承关系

1）ByteStreamLiveSource

live555转发DVB实时流（TS流）数据_第3张图片

2）MPEG2TransportLiveServerMediaSubsession

live555转发DVB实时流（TS流）数据_第4张图片

三、这两个类的实现

1）定义一个数据类型，用于存放从DVB中读取到的数据

    文件名称：LiveTSType.hh

    说明：因为我们读取的实时TS流数据，所以需要定时的为数据增加PAT表和PMT表，以使客户端随时能够获取TS流中的音视频格式信息。

[cpp]  view plain  copy
  1. #ifndef __LIVE_TS_BUFFER_TYPE_HH  
  2. #define __LIVE_TS_BUFFER_TYPE_HH  
  3.   
  4. #ifdef __cplusplus  
  5. extern "C"{  
  6. #endif  
  7.   
  8. #define TRANSPORT_SYNC_BYTE 0x47        // TS流同步字节  
  9. #define REC_BUF_MAX_LEN 256*1024+2*188  // 每个buffer的有效数据长度为256K字节,多出的2*188字节存放PAT表和PMT表  
  10.   
  11. typedef struct s_buffer   
  12. {  
  13.     unsigned char   buf_writing;        // buffer是否处于被写状态，buffer在写入状态不稳定，需要等待写完成才能读取  
  14.     unsigned int    buf_len;            // 写入数据的实际长度  
  15.     unsigned int    buf_read_counter;   // 记录已经读取的字节数  
  16.     unsigned char   buf_data[REC_BUF_MAX_LEN];  // 存放数据的buffer  
  17. } t_TS_Buffer;  
  18.   
  19. #ifdef __cplusplus  
  20. }  
  21. #endif  
  22.   
  23.   
  24. #endif  

2）ByteStreamLiveSource类

    文件名称：ByteStreamLiveSource.hh

[cpp]  view plain  copy
  1. #ifndef _BYTE_STREAM_LIVE_SOURCE_HH  
  2. #define _BYTE_STREAM_LIVE_SOURCE_HH  
  3.   
  4. #ifndef _FRAMED_SOURCE_HH  
  5. #include "FramedSource.hh"  
  6. #endif  
  7.   
  8. #ifndef __LIVE_TS_BUFFER_TYPE_HH  
  9. #include "LiveTSType.hh"  
  10. #endif  
  11.   
  12.   
  13. class ByteStreamLiveSource: public FramedSource   
  14. {  
  15. public:  
  16.     static ByteStreamLiveSource* createNew(UsageEnvironment& env,  
  17.                          t_TS_Buffer *p_tsbuf,  
  18.                          unsigned preferredFrameSize = 0,  
  19.                          unsigned playTimePerFrame = 0);  
  20.   
  21.   
  22.     //void seekToByteAbsolute(u_int64_t byteNumber, u_int64_t numBytesToStream = 0);  
  23.     // if "numBytesToStream" is >0, then we limit the stream to that number of bytes, before treating it as EOF  
  24.     //void seekToByteRelative(int64_t offset, u_int64_t numBytesToStream = 0);  
  25.     //void seekToEnd(); // to force EOF handling on the next read  
  26.   
  27. protected:  
  28.     ByteStreamLiveSource(UsageEnvironment& env,  
  29.                t_TS_Buffer *p_tsbuf,  
  30.                unsigned preferredFrameSize,  
  31.                unsigned playTimePerFrame);  
  32.     // called only by createNew()  
  33.   
  34.     virtual ~ByteStreamLiveSource();  
  35.   
  36.     //static void fileReadableHandler(ByteStreamFileSource* source, int mask);  
  37.     void doReadFromBuffer();  
  38.   
  39. private:  
  40.     // redefined virtual functions:  
  41.     virtual void doGetNextFrame();  
  42.     virtual void doStopGettingFrames();  
  43.   
  44. private:  
  45.     unsigned fPreferredFrameSize;  
  46.     unsigned fPlayTimePerFrame;  
  47.     //Boolean fFidIsSeekable;  
  48.     unsigned fLastPlayTime;  
  49.     Boolean fHaveStartedReading;  
  50.     Boolean fLimitNumBytesToStream;  
  51.     u_int64_t fNumBytesToStream; // used iff "fLimitNumBytesToStream" is True  
  52.   
  53.     // Added by zhaoyulei, for live ts buffer  
  54.     t_TS_Buffer *fPTsBuf;       // TS流buffer数据指针  
  55.     t_TS_Buffer fLocalBuf;      // 本地buffer  
  56. };  
  57.   
  58. #endif  


    文件名称：ByteStreamLiveSource.cpp

    说明：需要注意的是异常处理，比如读到的数据第一个字节不是0x47的情形。代码中的注释比较详细，不再细说。

[cpp]  view plain  copy
  1. #include "ByteStreamLiveSource.hh"  
  2. #include "GroupsockHelper.hh"  
  3.   
  4. ////////// ByteStreamLiveSource //////////  
  5.   
  6. #include "LiveTSType.hh"  
  7.   
  8. ByteStreamLiveSource*  
  9. ByteStreamLiveSource::createNew(UsageEnvironment& env,   
  10.                 t_TS_Buffer *p_tsbuf,  
  11.                 unsigned preferredFrameSize,  
  12.                 unsigned playTimePerFrame)  
  13. {  
  14.     printf("=== zyl ===, %s, %d\n",__FILE__, __LINE__);  
  15.   
  16.     if (p_tsbuf == NULL)   
  17.         return NULL;  
  18.   
  19.     ByteStreamLiveSource* newSource  
  20.         = new ByteStreamLiveSource(env, p_tsbuf, preferredFrameSize, playTimePerFrame);  
  21.     //newSource->fPTsBuf = p_tsbuf;  
  22.     // 初始化  
  23.     newSource->fLocalBuf.buf_writing = 0;  
  24.     newSource->fLocalBuf.buf_len = 0;  
  25.     newSource->fLocalBuf.buf_read_counter = 0;  
  26.     memset(newSource->fLocalBuf.buf_data, 0, REC_BUF_MAX_LEN);  
  27.   
  28.     return newSource;  
  29. }  
  30.   
  31. ByteStreamLiveSource::ByteStreamLiveSource(UsageEnvironment& env,   
  32.                         t_TS_Buffer *p_tsbuf,  
  33.                         unsigned preferredFrameSize,  
  34.                         unsigned playTimePerFrame)  
  35.   : FramedSource(env), fPTsBuf(p_tsbuf),fPreferredFrameSize(preferredFrameSize),  
  36.     fPlayTimePerFrame(playTimePerFrame), fLastPlayTime(0),  
  37.     fHaveStartedReading(False), fLimitNumBytesToStream(False), fNumBytesToStream(0)   
  38. {  
  39.   
  40. }  
  41.   
  42. ByteStreamLiveSource::~ByteStreamLiveSource()   
  43. {  
  44.   
  45. }  
  46.   
  47. void ByteStreamLiveSource::doGetNextFrame()   
  48. {  
  49.     if (fLimitNumBytesToStream && fNumBytesToStream == 0)   
  50.     {  
  51.         handleClosure();  
  52.         return;  
  53.     }  
  54.   
  55.     doReadFromBuffer();  
  56. }  
  57.   
  58. void ByteStreamLiveSource::doStopGettingFrames()   
  59. {  
  60.     envir().taskScheduler().unscheduleDelayedTask(nextTask());  
  61. }  
  62.   
  63. void ByteStreamLiveSource::doReadFromBuffer()   
  64. {  
  65.     //printf("=== zyl ===, %s, %d\n",__FILE__, __LINE__);  
  66.     //初始化计数器  
  67.     unsigned int readLen = 0;   
  68.     unsigned int syncBytePosition = 0;  
  69.   
  70.     // 没用，之前确定最多读取字节数的变量  
  71.     fMaxSize = fPreferredFrameSize;  
  72.   
  73.     //printf("=== zyl ===, fLocalBuf.buf_read_counter = %d, fLocalBuf.buf_len = %d\n",  
  74.     //            fLocalBuf.buf_read_counter, fLocalBuf.buf_len);  
  75.     //初始化Frame Size   
  76.     fFrameSize = 0;  
  77.   
  78.     //如果剩余的字节数不够，先读取剩余的字节数  
  79.     if((fLocalBuf.buf_len - fLocalBuf.buf_read_counter) < fPreferredFrameSize)  
  80.     {  
  81.         // fMaxSize = fLocalBuf.buf_len - fLocalBuf.buf_read_counter;  
  82.         // 确定要读取的字节数  
  83.         readLen = fLocalBuf.buf_len - fLocalBuf.buf_read_counter;  
  84.   
  85.         // 读取这些字节  
  86.         memcpy(fTo, (fLocalBuf.buf_data + fLocalBuf.buf_read_counter), readLen);  
  87.         //fMaxSize += fLocalBuf.buf_len - fLocalBuf.buf_read_counter;  
  88.   
  89.         // 已经读取字节数统计值  
  90.         fLocalBuf.buf_read_counter += readLen;  
  91.   
  92.         // 当前Frame Size  
  93.         fFrameSize += readLen;  
  94.     }  
  95.                   
  96.     // 如果已经读完一个buffer  
  97.     if(fLocalBuf.buf_read_counter == fLocalBuf.buf_len)  
  98.     {  
  99.         while(fPTsBuf->buf_writing !=0 )  
  100.         {  
  101.             printf("=== zyl === waiting for buf_writing\n");  
  102.         };  
  103.         #if 0  
  104.         for(i = 0; i < 188; i++)  
  105.         {  
  106.             printf("%02x, ", fPTsBuf->buf_data[i]);  
  107.             if ((i+1)%16 == 0)  
  108.                 printf("\n");  
  109.         }  
  110.         printf("\n");  
  111.         #endif  
  112.         memcpy(fLocalBuf.buf_data, fPTsBuf->buf_data, fPTsBuf->buf_len);  
  113.         fLocalBuf.buf_read_counter = 0;  
  114.         fLocalBuf.buf_len = fPTsBuf->buf_len;  
  115.     }  
  116.   
  117.     // 如果已经读取的字节数不够  
  118.     if(fFrameSize < fPreferredFrameSize)  
  119.     {  
  120.         // 还需要读取这些字节的数据  
  121.         readLen = fPreferredFrameSize - fFrameSize;  
  122.   
  123.         // 读取这些字节，当然，起始地址需要改变一下  
  124.         memcpy(fTo+fFrameSize, (fLocalBuf.buf_data + fLocalBuf.buf_read_counter), readLen);  
  125.           
  126.         // 已经读取字节数统计值  
  127.         fLocalBuf.buf_read_counter += readLen;  
  128.           
  129.         // 当前Frame Size  
  130.         fFrameSize += readLen;  
  131.     }  
  132.   
  133.     // 如果读到的buffer第一个字节不是0x47  
  134.       
  135.     while(TRANSPORT_SYNC_BYTE != fTo[syncBytePosition])  
  136.     {  
  137.         syncBytePosition++;  
  138.     }  
  139.     if(0 != syncBytePosition)  
  140.     {  
  141.         printf("=== zyl === syncBytePosition !=0\n");  
  142.         memmove(fTo, &fTo[syncBytePosition], fFrameSize - syncBytePosition);  
  143.         fFrameSize -= syncBytePosition;  
  144.           
  145.         // 如果已经读取的字节数不够  
  146.         if(fFrameSize < fPreferredFrameSize)  
  147.         {  
  148.             // 还需要读取这些字节的数据  
  149.             readLen = fPreferredFrameSize - fFrameSize;  
  150.   
  151.             // 读取这些字节，当然，起始地址需要改变一下  
  152.             memcpy(fTo+fFrameSize, (fLocalBuf.buf_data + fLocalBuf.buf_read_counter), readLen);  
  153.               
  154.             // 已经读取字节数统计值  
  155.             fLocalBuf.buf_read_counter += readLen;  
  156.               
  157.             // 当前Frame Size  
  158.             fFrameSize += readLen;  
  159.         }  
  160.     }  
  161.       
  162.   
  163.     //printf("=== zyl === ,fLocalBuf.buf_read_counter = %d, fLocalBuf.buf_len = %d\n",  
  164.     //            fLocalBuf.buf_read_counter, fLocalBuf.buf_len);  
  165.   
  166.     if (fFrameSize == 0)   
  167.     {  
  168.         handleClosure();  
  169.         return;  
  170.     }  
  171.     //fNumBytesToStream -= fFrameSize;  
  172.   
  173.     // Set the 'presentation time':  
  174.     if (fPlayTimePerFrame > 0 && fPreferredFrameSize > 0)   
  175.     {  
  176.         if (fPresentationTime.tv_sec == 0 && fPresentationTime.tv_usec == 0)   
  177.         {  
  178.             // This is the first frame, so use the current time:  
  179.             gettimeofday(&fPresentationTime, NULL);  
  180.         }   
  181.         else  
  182.         {  
  183.             // Increment by the play time of the previous data:  
  184.             unsigned uSeconds   = fPresentationTime.tv_usec + fLastPlayTime;  
  185.             fPresentationTime.tv_sec += uSeconds/1000000;  
  186.             fPresentationTime.tv_usec = uSeconds%1000000;  
  187.         }  
  188.   
  189.         // Remember the play time of this data:  
  190.         fLastPlayTime = (fPlayTimePerFrame*fFrameSize)/fPreferredFrameSize;  
  191.         fDurationInMicroseconds = fLastPlayTime;  
  192.     }   
  193.     else   
  194.     {  
  195.         // We don't know a specific play time duration for this data,  
  196.         // so just record the current time as being the 'presentation time':  
  197.         gettimeofday(&fPresentationTime, NULL);  
  198.     }  
  199.   
  200.     // Inform the reader that he has data:  
  201.     // Because the file read was done from the event loop, we can call the  
  202.     // 'after getting' function directly, without risk of infinite recursion:  
  203.     FramedSource::afterGetting(this);  
  204. }  

3）MPEG2TransportLiveServerMediaSubsession类

    文件名称：MPEG2TransportLiveServerMediaSubsession.hh

    说明：参照MPEG2TransportFileServerMediaSubsession类，把不需要的代码给删除掉

[cpp]  view plain  copy
  1. #ifndef _MPEG2_TRANSPORT_LIVE_SERVER_MEDIA_SUBSESSION_HH  
  2. #define _MPEG2_TRANSPORT_LIVE_SERVER_MEDIA_SUBSESSION_HH  
  3.   
  4. #ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH  
  5. #include "OnDemandServerMediaSubsession.hh"  
  6. #endif  
  7. #ifndef _MPEG2_TRANSPORT_STREAM_FRAMER_HH  
  8. #include "MPEG2TransportStreamFramer.hh"  
  9. #endif  
  10. #ifndef _BYTE_STREAM_LIVE_SOURCE_HH  
  11. #include "ByteStreamLiveSource.hh"  
  12. #endif  
  13. #ifndef _MPEG2_TRANSPORT_STREAM_TRICK_MODE_FILTER_HH  
  14. #include "MPEG2TransportStreamTrickModeFilter.hh"  
  15. #endif  
  16. #ifndef _MPEG2_TRANSPORT_STREAM_FROM_ES_SOURCE_HH  
  17. #include "MPEG2TransportStreamFromESSource.hh"  
  18. #endif  
  19.   
  20. #ifndef __LIVE_TS_BUFFER_TYPE_HH  
  21. #include "LiveTSType.hh"  
  22. #endif  
  23.   
  24.   
  25. //class ClientTrickPlayState; // forward  
  26.   
  27. class MPEG2TransportLiveServerMediaSubsession: public OnDemandServerMediaSubsession  
  28. {  
  29. public:  
  30.     static MPEG2TransportLiveServerMediaSubsession* createNew(UsageEnvironment& env,  
  31.                 Boolean reuseFirstSource,  
  32.                 t_TS_Buffer *p_tsbuf);  
  33.   
  34. protected:  
  35.     MPEG2TransportLiveServerMediaSubsession(UsageEnvironment& env,  
  36.                 Boolean reuseFirstSource,  
  37.                 t_TS_Buffer *p_tsbuf);  
  38.                 // called only by createNew();  
  39.     virtual ~MPEG2TransportLiveServerMediaSubsession();  
  40.   
  41.     //virtual ClientTrickPlayState* newClientTrickPlayState();  
  42.   
  43. private: // redefined virtual functions  
  44.   // Note that because - to implement 'trick play' operations - we're operating on  
  45.   // more than just the input source, we reimplement some functions that are  
  46.   // already implemented in "OnDemandServerMediaSubsession", rather than  
  47.   // reimplementing "seekStreamSource()" and "setStreamSourceScale()":  
  48.     virtual void startStream(unsigned clientSessionId, void* streamToken,  
  49.                 TaskFunc* rtcpRRHandler,  
  50.                 void* rtcpRRHandlerClientData,  
  51.                 unsigned short& rtpSeqNum,  
  52.                 unsigned& rtpTimestamp,  
  53.                 ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,  
  54.                 void* serverRequestAlternativeByteHandlerClientData);  
  55.     virtual void pauseStream(unsigned clientSessionId, void* streamToken);  
  56.     virtual void seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT, double streamDuration, u_int64_t& numBytes);  
  57.     virtual void setStreamScale(unsigned clientSessionId, void* streamToken, float scale);  
  58.     virtual void deleteStream(unsigned clientSessionId, void*& streamToken);  
  59.   
  60.     // The virtual functions thare are usually implemented by "ServerMediaSubsession"s:  
  61.     virtual FramedSource* createNewStreamSource(unsigned clientSessionId,  
  62.                 unsigned& estBitrate);  
  63.     virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,  
  64.                 unsigned char rtpPayloadTypeIfDynamic,  
  65.                 FramedSource* inputSource);  
  66.   
  67.     virtual void testScaleFactor(float& scale);  
  68.     virtual float duration() const;  
  69.   
  70. private:  
  71.     //ClientTrickPlayState* lookupClient(unsigned clientSessionId);  
  72.   
  73. private:  
  74. //    MPEG2TransportStreamIndexFile* fIndexFile;  
  75.     float fDuration;  
  76.     HashTable* fClientSessionHashTable; // indexed by client session id  
  77.   
  78.     // The live ts buffer, added by zhaoyulei, 2015.06.01  
  79.     t_TS_Buffer *fPTsBuf;  // buffer指针  
  80.     
  81. };  

    文件名称：MPEG2TransportLiveServerMediaSubsession.cpp

    说明：参照MPEG2TransportFileServerMediaSubsession类，把不需要的代码给删除掉

[cpp]  view plain  copy
  1. #include "MPEG2TransportLiveServerMediaSubsession.hh"  
  2. #include "SimpleRTPSink.hh"  
  3. #include "LiveTSType.hh"  
  4. #include   
  5.   
  6. MPEG2TransportLiveServerMediaSubsession*  
  7. MPEG2TransportLiveServerMediaSubsession::createNew(  
  8.                 UsageEnvironment&   env,  
  9.                 Boolean             reuseFirstSource,  
  10.                 t_TS_Buffer*        p_tsbuf)  
  11. {  
  12.     // printf("=== zyl ===, %s, %d\n",__FILE__, __LINE__);  
  13.   
  14.     MPEG2TransportLiveServerMediaSubsession* newpSubsession =  
  15.     new MPEG2TransportLiveServerMediaSubsession(env,  
  16.                              reuseFirstSource, p_tsbuf);  
  17.     //newpSubsession->fPTsBuf = p_tsbuf;   
  18.     return newpSubsession;  
  19. }  
  20.   
  21.   
  22. MPEG2TransportLiveServerMediaSubsession  
  23. ::MPEG2TransportLiveServerMediaSubsession(  
  24.                 UsageEnvironment&               env,  
  25.                 Boolean                         reuseFirstSource,  
  26.                 t_TS_Buffer*                    p_tsbuf)  
  27. : OnDemandServerMediaSubsession(env, reuseFirstSource),fPTsBuf(p_tsbuf),  
  28. fDuration(0.0), fClientSessionHashTable(NULL)   
  29. {  
  30.   
  31. }  
  32.   
  33. MPEG2TransportLiveServerMediaSubsession  
  34. ::~MPEG2TransportLiveServerMediaSubsession()   
  35. {  
  36. }  
  37.   
  38. #define TRANSPORT_PACKET_SIZE 188  
  39. #define TRANSPORT_PACKETS_PER_NETWORK_PACKET 7  
  40. // The product of these two numbers must be enough to fit within a network packet  
  41.   
  42. void MPEG2TransportLiveServerMediaSubsession  
  43. ::startStream(unsigned clientSessionId, void* streamToken, TaskFunc* rtcpRRHandler,  
  44.           void* rtcpRRHandlerClientData, unsigned short& rtpSeqNum,  
  45.           unsigned& rtpTimestamp,  
  46.           ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,  
  47.           void* serverRequestAlternativeByteHandlerClientData)   
  48. {  
  49.     // Call the original, default version of this routine:  
  50.     OnDemandServerMediaSubsession::startStream(clientSessionId, streamToken,  
  51.                          rtcpRRHandler, rtcpRRHandlerClientData,  
  52.                          rtpSeqNum, rtpTimestamp,  
  53.                          serverRequestAlternativeByteHandler, serverRequestAlternativeByteHandlerClientData);  
  54. }  
  55.   
  56. void MPEG2TransportLiveServerMediaSubsession  
  57. ::pauseStream(unsigned clientSessionId, void* streamToken)   
  58. {  
  59.     // Call the original, default version of this routine:  
  60.     OnDemandServerMediaSubsession::pauseStream(clientSessionId, streamToken);  
  61. }  
  62.   
  63. void MPEG2TransportLiveServerMediaSubsession  
  64. ::seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT, double streamDuration, u_int64_t& numBytes)   
  65. {  
  66.     // Begin by calling the original, default version of this routine:  
  67.     OnDemandServerMediaSubsession::seekStream(clientSessionId, streamToken, seekNPT, streamDuration, numBytes);  
  68.   
  69. }  
  70.   
  71. void MPEG2TransportLiveServerMediaSubsession  
  72. ::setStreamScale(unsigned clientSessionId, void* streamToken, float scale)   
  73. {  
  74.   
  75.     // Call the original, default version of this routine:  
  76.     OnDemandServerMediaSubsession::setStreamScale(clientSessionId, streamToken, scale);  
  77. }  
  78.   
  79. void MPEG2TransportLiveServerMediaSubsession  
  80. ::deleteStream(unsigned clientSessionId, void*& streamToken)   
  81. {  
  82.   
  83.     // Call the original, default version of this routine:  
  84.     OnDemandServerMediaSubsession::deleteStream(clientSessionId, streamToken);  
  85. }  
  86.   
  87. FramedSource* MPEG2TransportLiveServerMediaSubsession  
  88. ::createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate)   
  89. {  
  90.     // Create the video source:  
  91.     unsigned const inputDataChunkSize  
  92.         = TRANSPORT_PACKETS_PER_NETWORK_PACKET*TRANSPORT_PACKET_SIZE;  
  93.   
  94.     // 使用自己定义的source  
  95.     ByteStreamLiveSource* liveSource  
  96.         = ByteStreamLiveSource::createNew(envir(), fPTsBuf,inputDataChunkSize);  
  97.   
  98.     estBitrate = 5000; // kbps, estimate  
  99.       
  100.   
  101.     // Create a framer for the Transport Stream:  
  102.     MPEG2TransportStreamFramer* framer  
  103.         = MPEG2TransportStreamFramer::createNew(envir(), liveSource);  
  104.   
  105.     return framer;  
  106. }  
  107.   
  108. RTPSink* MPEG2TransportLiveServerMediaSubsession  
  109. ::createNewRTPSink(Groupsock* rtpGroupsock,  
  110.            unsigned char /*rtpPayloadTypeIfDynamic*/,  
  111.            FramedSource* /*inputSource*/)   
  112. {  
  113.     return SimpleRTPSink::createNew(envir(), rtpGroupsock,  
  114.                   33, 90000, "video", "MP2T",  
  115.                   1, True, False /*no 'M' bit*/);  
  116. }  
  117.   
  118. void MPEG2TransportLiveServerMediaSubsession::testScaleFactor(float& scale)   
  119. {  
  120.         scale = 1.0f;  
  121. }  
  122.   
  123. float MPEG2TransportLiveServerMediaSubsession::duration() const   
  124. {  
  125.     return fDuration;  
  126. }  

    这样我们需要的两个类就创建好了，最主要的工作算完成了

四、修改DynamicRTSPServer类，增加我们的媒体类型

1）修改DynamicRTSPServer.hh，重定义一个createNew成员函数，增加一个私有的t_TS_Buffer * 型成员

[cpp]  view plain  copy
  1. #ifndef _DYNAMIC_RTSP_SERVER_HH  
  2. #define _DYNAMIC_RTSP_SERVER_HH  
  3.   
  4. #ifndef _RTSP_SERVER_SUPPORTING_HTTP_STREAMING_HH  
  5. #include "RTSPServerSupportingHTTPStreaming.hh"  
  6. #endif  
  7.   
  8. #ifndef __LIVE_TS_BUFFER_TYPE_HH  
  9. #include "LiveTSType.hh"  
  10. #endif  
  11.   
  12. class DynamicRTSPServer: public RTSPServerSupportingHTTPStreaming {  
  13. public:  
  14.   static DynamicRTSPServer* createNew(UsageEnvironment& env, Port ourPort,  
  15.                       UserAuthenticationDatabase* authDatabase,  
  16.                       unsigned reclamationTestSeconds = 65);  
  17.                         
  18.     // 新的createNew,可以传递t_TS_Buffer指针  
  19.     static DynamicRTSPServer* createNew(UsageEnvironment& env, Port ourPort,  
  20.                       UserAuthenticationDatabase* authDatabase,  
  21.                       t_TS_Buffer *p_tsbuf,  
  22.                       unsigned reclamationTestSeconds = 65);  
  23.   
  24. protected:  
  25.   DynamicRTSPServer(UsageEnvironment& env, int ourSocket, Port ourPort,  
  26.             UserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds);  
  27.   // called only by createNew();  
  28.   virtual ~DynamicRTSPServer();  
  29.   
  30. protected: // redefined virtual functions  
  31.   virtual ServerMediaSession*  
  32.   lookupServerMediaSession(char const* streamName, Boolean isFirstLookupInSession);  
  33.   
  34. private:  
  35.     // The live ts buffer, added by zhaoyulei, 2015.06.01  
  36.     // t_TS_Buffer指针  
  37.     t_TS_Buffer *fPTsBuf;  
  38. };  
  39.   
  40. #endif  

3、修改DynamicRTSPServer.cpp，

[cpp]  view plain  copy
  1. #include "DynamicRTSPServer.hh"  
  2. #include   
  3. #include   
  4.   
  5. DynamicRTSPServer*  
  6. DynamicRTSPServer::createNew(UsageEnvironment& env, Port ourPort,  
  7.                  UserAuthenticationDatabase* authDatabase,  
  8.                  unsigned reclamationTestSeconds) {  
  9.     int ourSocket = setUpOurSocket(env, ourPort);  
  10.     if (ourSocket == -1) return NULL;  
  11.   
  12.     return new DynamicRTSPServer(env, ourSocket, ourPort, authDatabase, reclamationTestSeconds);  
  13. }  
  14.   
  15. // 新的createNew函数  
  16. DynamicRTSPServer*  
  17. DynamicRTSPServer::createNew(UsageEnvironment& env, Port ourPort,  
  18.                  UserAuthenticationDatabase* authDatabase,  
  19.                  t_TS_Buffer *p_tsbuf,  
  20.                  unsigned reclamationTestSeconds)   
  21. {  
  22.     int ourSocket = setUpOurSocket(env, ourPort);  
  23.     if (ourSocket == -1) return NULL;  
  24.   
  25.     DynamicRTSPServer* newDynamicRTSPServer =  
  26.             new DynamicRTSPServer(env, ourSocket, ourPort, authDatabase, reclamationTestSeconds);  
  27.     newDynamicRTSPServer->fPTsBuf = p_tsbuf;  
  28.     return newDynamicRTSPServer;  
  29. }  
  30.   
  31. DynamicRTSPServer::DynamicRTSPServer(UsageEnvironment& env, int ourSocket,  
  32.                      Port ourPort,  
  33.                      UserAuthenticationDatabase* authDatabase, unsigned reclamationTestSeconds)  
  34.   : RTSPServerSupportingHTTPStreaming(env, ourSocket, ourPort, authDatabase, reclamationTestSeconds),  
  35.   fPTsBuf(NULL)  
  36. {  
  37. }  
  38.   
  39. DynamicRTSPServer::~DynamicRTSPServer() {  
  40. }  
  41.   
  42. static ServerMediaSession* createNewSMS(UsageEnvironment& env,  
  43.                     char const* fileName, FILE* fid, t_TS_Buffer *p_tsbuf); // forward  
  44.   
  45. ServerMediaSession* DynamicRTSPServer  
  46. ::lookupServerMediaSession(char const* streamName, Boolean isFirstLookupInSession)   
  47. {  
  48.     // First, check whether the specified "streamName" exists as a local file:  
  49.       
  50.     FILE* fid = fopen(streamName, "rb");  
  51.     Boolean fileExists = fid != NULL;  
  52.     // 处理新的数据类型  
  53.     if (strcmp(streamName, "live") == 0)  
  54.     {  
  55.         fileExists = 1;  
  56.     }  
  57.       
  58.     // Next, check whether we already have a "ServerMediaSession" for this file:  
  59.     ServerMediaSession* sms = RTSPServer::lookupServerMediaSession(streamName);  
  60.     Boolean smsExists = sms != NULL;  
  61.   
  62.   // Handle the four possibilities for "fileExists" and "smsExists":  
  63.   if (!fileExists) {  
  64.     if (smsExists) {  
  65.       // "sms" was created for a file that no longer exists. Remove it:  
  66.       removeServerMediaSession(sms);  
  67.       sms = NULL;  
  68.     }  
  69.   
  70.     return NULL;  
  71.   } else {  
  72.     if (smsExists && isFirstLookupInSession) {   
  73.       // Remove the existing "ServerMediaSession" and create a new one, in case the underlying  
  74.       // file has changed in some way:  
  75.       removeServerMediaSession(sms);   
  76.       sms = NULL;  
  77.     }   
  78.         // 处理新的数据类型  
  79.         if (sms == NULL)   
  80.         {  
  81.             sms = createNewSMS(envir(), streamName, fid, fPTsBuf);   
  82.             addServerMediaSession(sms);  
  83.         }  
  84.         if(fileExists && (strcmp(streamName, "live") != 0))  
  85.         {  
  86.             fclose(fid);  
  87.         }  
  88.         return sms;  
  89.     }  
  90. }  
  91.   
  92. // Special code for handling Matroska files:  
  93. struct MatroskaDemuxCreationState {  
  94.   MatroskaFileServerDemux* demux;  
  95.   char watchVariable;  
  96. };  
  97. static void onMatroskaDemuxCreation(MatroskaFileServerDemux* newDemux, void* clientData) {  
  98.   MatroskaDemuxCreationState* creationState = (MatroskaDemuxCreationState*)clientData;  
  99.   creationState->demux = newDemux;  
  100.   creationState->watchVariable = 1;  
  101. }  
  102. // END Special code for handling Matroska files:  
  103.   
  104. // Special code for handling Ogg files:  
  105. struct OggDemuxCreationState {  
  106.   OggFileServerDemux* demux;  
  107.   char watchVariable;  
  108. };  
  109. static void onOggDemuxCreation(OggFileServerDemux* newDemux, void* clientData) {  
  110.   OggDemuxCreationState* creationState = (OggDemuxCreationState*)clientData;  
  111.   creationState->demux = newDemux;  
  112.   creationState->watchVariable = 1;  
  113. }  
  114. // END Special code for handling Ogg files:  
  115.   
  116. #define NEW_SMS(description) do {\  
  117. char const* descStr = description\  
  118.     ", streamed by the LIVE555 Media Server";\  
  119. sms = ServerMediaSession::createNew(env, fileName, fileName, descStr);\  
  120. } while(0)  
  121.   
  122. static ServerMediaSession* createNewSMS(UsageEnvironment& env,  
  123.                     char const* fileName, FILE* /*fid*/, t_TS_Buffer *p_tsbuf) {  
  124.   // Use the file name extension to determine the type of "ServerMediaSession":  
  125.     char const* extension = strrchr(fileName, '.');  
  126.     if (strcmp(fileName, "live") == 0)  
  127.     {  
  128.         extension = "live";  
  129.     }  
  130.   
  131.   if (extension == NULL) return NULL;  
  132.   
  133.   ServerMediaSession* sms = NULL;  
  134.   Boolean const reuseSource = False;  
  135.   if (strcmp(extension, ".aac") == 0) {  
  136.     // Assumed to be an AAC Audio (ADTS format) file:  
  137.     NEW_SMS("AAC Audio");  
  138.     sms->addSubsession(ADTSAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));  
  139.   } else if (strcmp(extension, ".amr") == 0) {  
  140.     // Assumed to be an AMR Audio file:  
  141.     NEW_SMS("AMR Audio");  
  142.     sms->addSubsession(AMRAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));  
  143.   } else if (strcmp(extension, ".ac3") == 0) {  
  144.     // Assumed to be an AC-3 Audio file:  
  145.     NEW_SMS("AC-3 Audio");  
  146.     sms->addSubsession(AC3AudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));  
  147.   } else if (strcmp(extension, ".m4e") == 0) {  
  148.     // Assumed to be a MPEG-4 Video Elementary Stream file:  
  149.     NEW_SMS("MPEG-4 Video");  
  150.     sms->addSubsession(MPEG4VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));  
  151.   } else if (strcmp(extension, ".264") == 0) {  
  152.     // Assumed to be a H.264 Video Elementary Stream file:  
  153.     NEW_SMS("H.264 Video");  
  154.     OutPacketBuffer::maxSize = 100000; // allow for some possibly large H.264 frames  
  155.     sms->addSubsession(H264VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));  
  156.   } else if (strcmp(extension, ".265") == 0) {  
  157.     // Assumed to be a H.265 Video Elementary Stream file:  
  158.     NEW_SMS("H.265 Video");  
  159.     OutPacketBuffer::maxSize = 100000; // allow for some possibly large H.265 frames  
  160.     sms->addSubsession(H265VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));  
  161.   } else if (strcmp(extension, ".mp3") == 0) {  
  162.     // Assumed to be a MPEG-1 or 2 Audio file:  
  163.     NEW_SMS("MPEG-1 or 2 Audio");  
  164.     // To stream using 'ADUs' rather than raw MP3 frames, uncomment the following:  
  165. //#define STREAM_USING_ADUS 1  
  166.     // To also reorder ADUs before streaming, uncomment the following:  
  167. //#define INTERLEAVE_ADUS 1  
  168.     // (For more information about ADUs and interleaving,  
  169.     //  see )  
  170.     Boolean useADUs = False;  
  171.     Interleaving* interleaving = NULL;  
  172. #ifdef STREAM_USING_ADUS  
  173.     useADUs = True;  
  174. #ifdef INTERLEAVE_ADUS  
  175.     unsigned char interleaveCycle[] = {0,2,1,3}; // or choose your own...  
  176.     unsigned const interleaveCycleSize  
  177.       = (sizeof interleaveCycle)/(sizeof (unsigned char));  
  178.     interleaving = new Interleaving(interleaveCycleSize, interleaveCycle);  
  179. #endif  
  180. #endif  
  181.     sms->addSubsession(MP3AudioFileServerMediaSubsession::createNew(env, fileName, reuseSource, useADUs, interleaving));  
  182.   } else if (strcmp(extension, ".mpg") == 0) {  
  183.     // Assumed to be a MPEG-1 or 2 Program Stream (audio+video) file:  
  184.     NEW_SMS("MPEG-1 or 2 Program Stream");  
  185.     MPEG1or2FileServerDemux* demux  
  186.       = MPEG1or2FileServerDemux::createNew(env, fileName, reuseSource);  
  187.     sms->addSubsession(demux->newVideoServerMediaSubsession());  
  188.     sms->addSubsession(demux->newAudioServerMediaSubsession());  
  189.   } else if (strcmp(extension, ".vob") == 0) {  
  190.     // Assumed to be a VOB (MPEG-2 Program Stream, with AC-3 audio) file:  
  191.     NEW_SMS("VOB (MPEG-2 video with AC-3 audio)");  
  192.     MPEG1or2FileServerDemux* demux  
  193.       = MPEG1or2FileServerDemux::createNew(env, fileName, reuseSource);  
  194.     sms->addSubsession(demux->newVideoServerMediaSubsession());  
  195.     sms->addSubsession(demux->newAC3AudioServerMediaSubsession());  
  196.   } else if (strcmp(extension, ".ts") == 0) {  
  197.     // Assumed to be a MPEG Transport Stream file:  
  198.     // Use an index file name that's the same as the TS file name, except with ".tsx":  
  199.     unsigned indexFileNameLen = strlen(fileName) + 2; // allow for trailing "x\0"  
  200.     char* indexFileName = new char[indexFileNameLen];  
  201.     sprintf(indexFileName, "%sx", fileName);  
  202.     NEW_SMS("MPEG Transport Stream");  
  203.     sms->addSubsession(MPEG2TransportFileServerMediaSubsession::createNew(env, fileName, indexFileName, reuseSource));  
  204.     delete[] indexFileName;  
  205.   } else if (strcmp(extension, ".wav") == 0) {  
  206.     // Assumed to be a WAV Audio file:  
  207.     NEW_SMS("WAV Audio Stream");  
  208.     // To convert 16-bit PCM data to 8-bit u-law, prior to streaming,  
  209.     // change the following to True:  
  210.     Boolean convertToULaw = False;  
  211.     sms->addSubsession(WAVAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource, convertToULaw));  
  212.   } else if (strcmp(extension, ".dv") == 0) {  
  213.     // Assumed to be a DV Video file  
  214.     // First, make sure that the RTPSinks' buffers will be large enough to handle the huge size of DV frames (as big as 288000).  
  215.     OutPacketBuffer::maxSize = 300000;  
  216.   
  217.     NEW_SMS("DV Video");  
  218.     sms->addSubsession(DVVideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));  
  219.   } else if (strcmp(extension, ".mkv") == 0 || strcmp(extension, ".webm") == 0) {  
  220.     // Assumed to be a Matroska file (note that WebM ('.webm') files are also Matroska files)  
  221.     OutPacketBuffer::maxSize = 100000; // allow for some possibly large VP8 or VP9 frames  
  222.     NEW_SMS("Matroska video+audio+(optional)subtitles");  
  223.   
  224.     // Create a Matroska file server demultiplexor for the specified file.  
  225.     // (We enter the event loop to wait for this to complete.)  
  226.     MatroskaDemuxCreationState creationState;  
  227.     creationState.watchVariable = 0;  
  228.     MatroskaFileServerDemux::createNew(env, fileName, onMatroskaDemuxCreation, &creationState);  
  229.     env.taskScheduler().doEventLoop(&creationState.watchVariable);  
  230.   
  231.     ServerMediaSubsession* smss;  
  232.     while ((smss = creationState.demux->newServerMediaSubsession()) != NULL) {  
  233.       sms->addSubsession(smss);  
  234.     }  
  235.   } else if (strcmp(extension, ".ogg") == 0 || strcmp(extension, ".ogv") == 0 || strcmp(extension, ".opus") == 0) {  
  236.     // Assumed to be an Ogg file  
  237.     NEW_SMS("Ogg video and/or audio");  
  238.   
  239.     // Create a Ogg file server demultiplexor for the specified file.  
  240.     // (We enter the event loop to wait for this to complete.)  
  241.     OggDemuxCreationState creationState;  
  242.     creationState.watchVariable = 0;  
  243.     OggFileServerDemux::createNew(env, fileName, onOggDemuxCreation, &creationState);  
  244.     env.taskScheduler().doEventLoop(&creationState.watchVariable);  
  245.   
  246.     ServerMediaSubsession* smss;  
  247.     while ((smss = creationState.demux->newServerMediaSubsession()) != NULL) {  
  248.       sms->addSubsession(smss);  
  249.     }  
  250.   }  
  251.     // 增加新的媒体类型"live",此类型不是根据文件名的后缀识别，而是全名  
  252.     else if (strcmp(extension, "live") == 0)  
  253.     {  
  254.         if (p_tsbuf != NULL)  
  255.         {  
  256.             NEW_SMS("MPEG2 Live Transport Stream");  
  257.             sms->addSubsession(MPEG2TransportLiveServerMediaSubsession::createNew(env,reuseSource, p_tsbuf));  
  258.         }  
  259.     }  
  260.   
  261.   return sms;  
  262. }  

四、主调函数的实现

1）在live555MediaServer.cpp的main函数基础上进行修改。

    增加一个头文件：live555MediaServer.h

[plain]  view plain  copy
  1. #ifndef __TCB_LIVE555_MEDIA_SERVER_HH_  
  2. #define __TCB_LIVE555_MEDIA_SERVER_HH_  
  3.   
  4.   
  5. #include "LiveTSType.hh"  
  6.   
  7.   
  8. #ifdef __cplusplus  
  9. extern "C"  
  10. {  
  11. #endif  
  12.   
  13. int live555ms_play(t_TS_Buffer *p_tsbuf);  
  14.   
  15. #ifdef __cplusplus  
  16. }  
  17. #endif  
  18.   
  19. #endif  
    

    修改live555MediaServer.cpp

[plain]  view plain  copy
  1. #include   
  2. #include "DynamicRTSPServer.hh"  
  3. #include "version.hh"  
  4. #include   
  5.   
  6. #include "live555MediaServer.h"  
  7. #include "LiveTSType.hh"  
  8. #include   
  9.   
  10. #include   
  11.   
  12. #define ZYL_DEBUG_LEVEL 5  
  13.   
  14. static int live555mediaserver(t_TS_Buffer *p_tsbuf)  
  15. {  
  16.     // 设置使用环境  
  17.     // 创建调度器  
  18.     TaskScheduler* scheduler = BasicTaskScheduler::createNew();  
  19.     // 创建交互环境  
  20.     UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);  
  21.   
  22.     // 用户数据库指针  
  23.     UserAuthenticationDatabase* authDB = NULL;  
  24. #ifdef ACCESS_CONTROL  
  25.     // 创建用户数据库  
  26.     authDB = new UserAuthenticationDatabase;  
  27.     // 添加用户  
  28.     authDB->addUserRecord("username1", "password1");  
  29. #endif  
  30.   
  31.     // 创建RTSP服务器，首先使用554端口号，如果不成功，则尝试使用8554  
  32.     RTSPServer* rtspServer;  
  33.     portNumBits rtspServerPortNum = 554;  
  34.     rtspServer = DynamicRTSPServer::createNew(*env, rtspServerPortNum, authDB, p_tsbuf);  
  35.     if (rtspServer == NULL)   
  36.     {  
  37.         rtspServerPortNum = 8554;  
  38.         rtspServer = DynamicRTSPServer::createNew(*env, rtspServerPortNum, authDB, p_tsbuf);  
  39.     }  
  40.     if (rtspServer == NULL)   
  41.     {  
  42.         *env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";  
  43.         exit(1);  
  44.     }  
  45.   
  46.     *env << "TCB LIVE555 Media Server\n";  
  47.     *env << "\tversion " << MEDIA_SERVER_VERSION_STRING  
  48.        << " (LIVE555 Streaming Media library version "  
  49.        << LIVEMEDIA_LIBRARY_VERSION_STRING << ").\n";  
  50.   
  51.     char* urlPrefix = rtspServer->rtspURLPrefix();  
  52.     *env << "Play streams from this server using the URL\n\t"  
  53.        << urlPrefix << "\nwhere  is a file present in the current directory.\n";  
  54.     *env << "Each file's type is inferred from its name suffix:\n";  
  55.     *env << "\t\".264\" => a H.264 Video Elementary Stream file\n";  
  56.     *env << "\t\".265\" => a H.265 Video Elementary Stream file\n";  
  57.     *env << "\t\".aac\" => an AAC Audio (ADTS format) file\n";  
  58.     *env << "\t\".ac3\" => an AC-3 Audio file\n";  
  59.     *env << "\t\".amr\" => an AMR Audio file\n";  
  60.     *env << "\t\".dv\" => a DV Video file\n";  
  61.     *env << "\t\".m4e\" => a MPEG-4 Video Elementary Stream file\n";  
  62.     *env << "\t\".mkv\" => a Matroska audio+video+(optional)subtitles file\n";  
  63.     *env << "\t\".mp3\" => a MPEG-1 or 2 Audio file\n";  
  64.     *env << "\t\".mpg\" => a MPEG-1 or 2 Program Stream (audio+video) file\n";  
  65.     *env << "\t\".ogg\" or \".ogv\" or \".opus\" => an Ogg audio and/or video file\n";  
  66.     *env << "\t\".ts\" => a MPEG Transport Stream file\n";  
  67.     *env << "\t\t(a \".tsx\" index file - if present - provides server 'trick play' support)\n";  
  68.     *env << "\t\".vob\" => a VOB (MPEG-2 video with AC-3 audio) file\n";  
  69.     *env << "\t\".wav\" => a WAV Audio file\n";  
  70.     *env << "\t\"live\" => a live ts profram\n";  
  71.     *env << "\t\".webm\" => a WebM audio(Vorbis)+video(VP8) file\n";  
  72.     *env << "See http://www.live555.com/mediaServer/ for additional documentation.\n";  
  73.   
  74.     // Also, attempt to create a HTTP server for RTSP-over-HTTP tunneling.  
  75.     // Try first with the default HTTP port (80), and then with the alternative HTTP  
  76.     // port numbers (8000 and 8080).  
  77.   
  78.     if (rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080))   
  79.     {  
  80.         *env << "(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling, or for HTTP live streaming (for indexed Transport Stream files only).)\n";  
  81.     }   
  82.     else   
  83.     {  
  84.         *env << "(RTSP-over-HTTP tunneling is not available.)\n";  
  85.     }  
  86.   
  87.     env->taskScheduler().doEventLoop(); // does not return  
  88.   
  89.     return 0; // only to prevent compiler warning  
  90. }  
  91. // live555主函数  
  92. int live555ms_play(t_TS_Buffer *p_tsbuf)  
  93. {  
  94.     printf("=== zyl ===, %s, %d\n",__FILE__, __LINE__);  
  95.     //return live_ts_rtsp_server(p_tsbuf);  
  96.     return live555mediaserver(p_tsbuf);  
  97. }  

五、函数调用

    以上是对整个live555部分的修改，在调用的时候，使用

[plain]  view plain  copy
  1. live555ms_play(t_TS_Buffer *p_tsbuf)  

传递存放数据的指针，当然，需要为Live555启动一个线程，因为这是一个不会返回的函数。

你可能感兴趣的:(流媒体技术)

  • 什么是云游戏？有什么优点？ Ogcloud_oversea 游戏
    云游戏是游戏行业的一个热门话题。随着5G网络的普及和技术的不断创新，云游戏的规模和受欢迎程度也不断提高。接下来我们来了解下云游戏是什么，以及它的优点。什么是云游戏？云游戏是一种游戏流媒体技术，它把游戏内容直接传输到用户的终端设备上，让用户在不拥有游戏软件和硬件的情况下，通过互联网来享受游戏的乐趣。用户只需要一款好的终端设备，并具备较快的网络速度，就可以随时玩游戏。云游戏技术可以在云服务器上运行，以
  • RTSP协议探秘：从原理到C++实践，解锁实时流媒体传输之道 baidu_huihui c++开发语言RTSPGStreamer
    原为地址：引言实时流媒体技术在现代信息传输和通信领域中扮演着重要角色。借助实时流媒体技术，人们可以实时观看或传输音频、视频内容，为在线教育、远程会议、视频监控等应用场景提供了强大的支持。本文将重点介绍实时流媒体的重要性、RTSP协议的简介、应用场景，以及RTSP协议的发展历程与前景。实时流媒体的重要性实时流媒体技术使得音频和视频内容能够在网络中实时传输和播放，为人们提供了更为便捷和高效的信息获取方
  • 流媒体技术基础-流媒体编码与协议 Mr_Michael
    一、流媒体传输协议各类协议详解1.实时传输协议RTP针对多媒体数据流的一种传输协议，建立在UDP协议上，属于传输层协议。定义互联网上传递音频和视频的标准数据包格式。RTP协议常用于流媒体系统（配合RTCP协议）、视频会议和视频电话系统（配合H.263或SIP）。2.实时传输控制协议RTCPRTCP为RTP媒体流提供信道外控制，定期在流多媒体会话参加者之间传输控制数据，属于传输层协议。。RTCP的主
  • 网络视频监控和流媒体技术-基础知识整理 威迪斯特 网络音视频媒体网络协议视频编解码视频
    经常有人问我网络视频监控上的一些基本概念，以及流媒体技术相关的一些概念和基础知识，这里整理一下，与大家分享。现在先整理这么多，可能还有不少没有，大家可以提出意见，我再加进去。1）OSI参考模型的层次是什么？有7个OSI层：物理层，数据链路层，网络层，传输层，会话层，表示层和应用层。2）什么是LAN？LAN是局域网的缩写。它是指计算机与位于小物理位置的其他网络设备之间的连接。3）什么是节点？节点是指
  • 基于SSM+VUE的音乐在线系统(毕业设计+论文) QQ3166678367 vue.js前端javascript
    摘要随着科学技术的不断发展，网络在我们的日常生活中正发挥着它重要的作用。现在，网络上传递的信息种类越来越多，从最初的文字信息发展到目前的文字、图象、声音、视频、动画等几乎所有种类的信息。因为需要传递的信息种类的增多，尤其是需要同时传递多种信息的时候，对计算机网络的数据传输技术也提出了新的要求。在线音乐网站就是近年来出现的比较新颖的运用流媒体技术的网络多媒体形式。通过建立霖听音乐网站管理系统可以帮助
  • 什么是流媒体 WongKyunban 音视频开发音视频ffmpeg
    所谓的流媒体是指将一连串的媒体数据压缩后，经过网络分段发送数据，在网上即时传输音视频以供观赏的一种技术。如果没有流媒体技术，那么在观赏前必须下载整个媒体文件。常见流媒体协议：RTSPRTPHTTPHLSRTMPHTTP-FLV等目前应用流媒体技术就多的场景就是直播场景。完整的直播系统包括以下这些过程：音视频采集音视频编码音视频推流音视频拉流音视频分发音视频转码认证鉴权还有响应政策方面的自动鉴黄它的
  • TSINGSEE青犀视频集成平台EasyCVR：支持多种视频流协议的强大功能 EasyDarwin EasyCVR音视频人工智能
    EasyCVR国标视频综合管理平台是一款以视频为核心的智慧物联应用平台。它基于分布式、负载均衡等流媒体技术进行开发，提供广泛兼容、安全可靠、开放共享的视频综合服务。该平台具备多种功能，包括视频直播、录像、回放、检索、云存储、告警上报、语音对讲、集群、智能AI分析以及平台级联共享等。视频监控综合管理平台EasyCVR具备视频融合能力，其基于云边端一体化架构，具有强大的数据接入、处理及分发能力。该平台
  • On-Demand 和自金融 曹博士
    On-Demand是源于互联网的一个概念。在互联网的发展初期，受带宽的限制，大的影视文件下载不只是慢，而且经常失败。流媒体(Streaming)技术通过引入buffer的机制。创建流媒体协议，通过流媒体服务器和播放器。可以实现边看边下载的on-demand模式，而且下载的状态可以随时改变，暂停和恢复，断点续传，降低了下载失败的风险，极大改善了用户的体验。没有流媒体技术就没有今天丰富多彩的内容和自媒
  • 三点带你解密为什么流媒体直播的延迟很高 十年编程老舅 音视频开发音视频音视频开发音视频编解码ffmpeg流媒体服务器srs流媒体传输协议
    通信技术的发展促进了视频点播和直播业务的兴起，4G和5G网络技术的进步也使得流媒体技术变得越来越重要，但是网络技术并不能解决流媒体直播的高延迟问题，本文不会介绍网络对直播业务的影响，而是会分析直播中常见的现象—主播和观众之间能够感觉到的明显网络延迟。除了业务上要求的延迟直播之外，有哪些因素会导致视频直播的延迟这么高呢？当观众通过弹幕与主播进行互动时，从我们看到弹幕到得到主播的响应可能要经过5s甚至
  • 从一个直播APP开发的流媒体系统的技术架构及应用进行总结 gate1001 移动互联网系统架构流媒体服务器直播appapp开发
    第一篇章流媒体原理1.1流媒体概念1.2流式传输特点1.3流媒体系统构成1.4流媒体涉及技术1.5流媒体应用1.6国内外大型流媒体系统1.7总结流媒体相关术语第二篇章流媒体系统2.1编码工具2.2流媒体服务器2.3CDN分发网络2.4网络协议2.5播放器总结：从一个直播APP看流媒体系统的应用通过第一篇流媒体原理和第二篇对流媒体系统的描述，我们大概能了解流媒体技术中的基本概念，以及一个大型流媒体系
  • 短视频短剧小程序系统：用技术丰富你的碎片时间 省钱兄科技 小程序
    在当今快节奏的生活中，人们的休闲时间变得越来越碎片化。短视频短剧小程序系统正是利用这一现象，通过技术手段为人们提供了丰富多样的娱乐内容，让碎片时间变得更加充实。一、短视频短剧小程序系统的技术特点高效加载与流畅播放：短视频短剧小程序系统采用了高效的加载技术和流媒体技术，确保用户在观看短剧时能够快速加载和流畅播放。这种技术特点让用户能够在碎片时间内轻松享受娱乐内容。智能推荐与个性化服务：基于大数据和人
  • FFmpeg入门详解之83：流媒体与直播技术 福优学苑@音视频+流媒体 福优学苑音视频/流媒体音视频流媒体直播
    流媒体流媒体又叫流式媒体，它是指商家用一个视频传送服务器(比如：vlc）把节目（比如：ande10.mp4）当成数据包发出，传送到网络上。用户通过解压设备对这些数据进行解压后，节目就会像发送前那样显示出来。这个过程的一系列相关的包称为“流”。流媒体实际指的是一种新的媒体传送方式，而非一种新的媒体。流媒体技术全面应用后，人们在网上聊天可直接语音输入；如果想彼此看见对方的容貌、表情，只要双方各有一个摄
  • 什么是RTMP 和 RTSP？它们之间有什么区别？ 一口Linux 笔记服务器网络运维
    视频盛行的时代，流媒体技术越来越重要，在本文中，我们将讨论两种流行的流媒体协议：RTMP和RTSP。什么是流协议？简单地说，流协议就是在两个通信系统之间传输多媒体文件的一套规则，它定义了视频文件将如何分解为小数据包以及它们在互联网上传输的顺序，RTMP与RTSP是比较常见的流媒体协议。RTMP英文全称：Real-TimeMessagingProtocol中文意思：实时消息传递协议还记得几年前，当您
  • 流媒体rtmp dengtieshan1 RTMP流媒体
    本文主要总结一些我在学习RTMP流媒体技术过程中积累的经验。也为后来学习RTMP流媒体技术的人们一个参考。本文力图从简到难，循序渐进的介绍RTMP流媒体技术的方方面面，先从应用说起，逐步深化剖析相关工程的源代码。看完本文的话应该会对RTMP流媒体技术有比较完整的了解。0.背景知识本章主要介绍一下RTMP流媒体技术都用在了哪里（在这里仅列几个我所知的，其实远比这个多）。说白了就是为了说明：RTMP是
  • 流媒体技术概述 徐步小兵 多媒体技术流媒体RTSP
    一、流媒体定义所谓流媒体，是指采用流式传输的方式在Iternet播放的媒体格式。流媒体又称流式媒体，是将普通多媒体，如音频、视频、动画等，经过特殊编码，使其成为在网络中使用流式传输的连续时基媒体，以适应在网络上边下载边播放的方式。其具有连续性、实时性、时序性三个特点。在这个过程中，网络上传输的一系列相关的数据包称为流（Stream）。二、流媒体特点1.启动延时大幅度地缩短用户不用等待所有内容下载到
  • 腾讯视频云流媒体技术探索 LiveVideoStack_ 网络传输视频编解码音视频实时音视频
    编者按：赛事直播场景与普通直播场景有一定差异，赛事直播场景对码率、画质、延时等性能要求更高。LiveVideoStackCon2022音视频技术大会上海站邀请到了腾讯专家工程师，媒体直播负责人——吴昊老师，为我们分享《腾讯视频云流媒体技术探索——赛事直播场景的技术优化》，他将介绍如何利用多路径传输、QoS控制，以及跨区调度和加速的能力，优化端到端的传输质量。在媒体处理和封装上，他将介绍通过多码率自
  • 视频教程-Flutter动画基础教程-flutter weixin_33415285
    Flutter动画基础教程捷智云视频会议系统联合创始人，国内首本Flutter出版书籍作者，著有《Flutter技术入门与实战》。多年从事流媒体技术研发，对于Android，iOS等开发技术有比较深入的研究和应用，作为主要程序员开发了多个应用项目，涉及医疗、交通、银行等领域。亢少军¥39.00立即订阅扫码下载「CSDN程序员学院APP」，1000+技术好课免费看APP订阅课程，领取优惠，最少立减5
  • 中国网络音频产品行业市场供需与战略研究报告 贝哲斯研究中心 网络音视频p2p其他
    【出版商】贝哲斯咨询【免费目录下载】网络音频产品使用蓝牙、云播或Play-fi软件等流媒体技术平滑地流媒体多种音频设备，为消费者提供更好的音乐选择和休闲享受，是现代生活中必不可少的娱乐工具。网络音频产品市场的企业竞争态势该报告涉及的主要国际市场参与者有Pioneer、SamsungElectronics、Sonos、Yamaha、CambridgeAudio、CirrusLogic、Denon、G
  • 基于OpenCV设计的流媒体播放器(RTSP、RTMP) DS小龙哥 FFMPEG音视频系列文章opencv人工智能计算机视觉
    一、前言随着互联网的普及和发展，流媒体技术已成为日常生活中不可或缺的一部分。流媒体播放器作为流媒体技术的重要组成部分，其性能和功能直接影响到用户的观影体验。本文介绍使用OpenCV和Qt设计一款流媒体播放器，专门用于播放直播视频流，例如RTSP、RTMP。该播放器只播放实时画面，不播放音频，同时支持播放本地视频，但需注意音画不同步的问题。通过OpenCV框架，能够方便地拉取各种类型的视频数据流，如
  • 音视频基础知识：流媒体核心技术梳理 潇湘落木life
    问题背景：这个公众号已经发了十几篇文章，阅读量和订阅数也在稳定增长。为了后面大家交流更顺畅，大概知道每篇文章在音视频技术体系的位置。利用周末画了个脑图，梳理了下音视频核心技术体系，当然这张图不会包含所有流媒体的技术，如果有遗漏，你可以私信我。我会在后面补充和丰富起来，让进门的小白能找到自己的位置，赠人玫瑰，手留余香。下面用两张图来构建音视频技术人交流的行话，让你快速找到在整个流媒体技术体系所处的位
  • 流媒体及直播相关知识 岁月指尖流 音视频开发流媒体直播
    文章目录前言一、流媒体1、基本概念2、流式传输3、流媒体技术原理4、流媒体传输模式5、H.264流媒体传输系统框架二、直播1、直播中使用的流媒体协议2、直播的模块划分3、视频直播流程①、推流到服务器②、服务器流分发前言本文主要讲解流媒体及其直播相关知识，所涉及的知识内容比较浅显，主要是做个简单的了解。一、流媒体1、基本概念流媒体又叫流式媒体，它是指商家用一个视频传送服务器（比如：vlc）把节目（比
  • Flutter开发的优势在哪里 吴怡may_wuyi
    感谢开源中国-高手问答栏目提供平台，原地址：https://www.oschina.net/question/2720166_2302950本文节选了18个问题的讨论。回答问题的嘉宾介绍：亢少军捷智云视频会议系统联合创始人，国内首本Flutter出版书籍作者，著有《Flutter技术入门与实战》。多年从事流媒体技术研发，对于Android，iOS等开发技术有比较深入的研究和应用，作为主要程序员开发
  • 直播平台源码开发搭建APP的DASH协议：流媒体技术其中一环 山东布谷科技官方 dash网络协议直播平台源码流媒体技术软件开发
    在直播平台源码APP中，有着许许多多、多种多样的功能，比如短视频功能，帮助我们去获取信息，看到全世界用户身边发生的事情或是他们的生活；又比如直播功能，为用户提供了实时的娱乐享受，还让一些用户成为了直播平台源码APP的主播，提供了随时随地工作挣钱的机会。然而这些功能都需要高质量实时的视频传输、超强的互动体验或是面对高负荷、高峰时期可以自动调整的动态自适应功能等。流媒体技术就是可以帮助直播平台源码AP
  • 直播平台源码开发搭建APP的DASH协议：流媒体技术其中一环
    在直播平台源码APP中，有着许许多多、多种多样的功能，比如短视频功能，帮助我们去获取信息，看到全世界用户身边发生的事情或是他们的生活；又比如直播功能，为用户提供了实时的娱乐享受，还让一些用户成为了直播平台源码APP的主播，提供了随时随地工作挣钱的机会。然而这些功能都需要高质量实时的视频传输、超强的互动体验或是面对高负荷、高峰时期可以自动调整的动态自适应功能等。流媒体技术就是可以帮助直播平台源码AP
  • 国标GB28181视频平台EasyCVR流媒体相关技术与实际场景应用的分析 EasyDarwin EasyCVR视频监控汇聚平台国标GB28181音视频
    随着互联网的不断发展，流媒体应用已经成为了人们生活中不可或缺的一部分。从在线音乐、视频到直播和游戏，流媒体技术的应用已经渗透到了人类的日常生活中。TSINGSEE青犀视频垂直深耕音视频流媒体技术、AI智能技术领域，目前已经拥有EasyCVR、EasyNVR、EasyGBS、EasyDSS、EasyRTC等覆盖各个场景与行业的流媒体视频平台。今天我们结合EasyCVR视频融合平台，来分享一下流媒体的
  • 山东布谷科技直播软件源码探索高效、稳定直播传输的技术介绍：流媒体传输技术 山东布谷科技官方 软件构建源码软件媒体开发语言实时音视频
    今天我们探索的是让直播软件源码平台在直播时能够高效、稳定的进行直播传输的技术，而这个技术就是直播软件源码平台的流媒体传输技术，在直播软件源码平台中，流媒体传输技术会将直播的图像、视频、音频等相关的流媒体信号通过网络传递到用户的端口，让用户可以正常地去看到直播的内容，听到直播的声音。流媒体技术在我们生活中很多地方都会应用，像是：游戏直播、线上教育培训、线上会议等，他们能够稳定、高效的进行，流媒体技术
  • 音视频 & 流媒体的原理以及基础入门知识 玩转音视频技术
    流媒体背景当下，音视频、流媒体已经无处不在，直播已经火了几年，在后续的时间里面，人们聊天已经不仅仅满足与文字、而是更多的在于“类面对面”交流，能够实时感知对方的表情、动作。为此，有必要跟紧时代潮流，好好梳理梳理流媒体这门功课。流媒体是什么？流媒体就是指采用流式传输技术在网络上连续实时播放的媒体格式，如音频、视频或多媒体文件。流媒体技术也称流式媒体技术。那么音视频就是流媒体的核心。音视频常见术语定义
  • 直播网站如何实现？ molecule_jp ffmpeg音视频网络
    现在的年轻人基本都爱刷B站和抖音，空闲时间还喜欢去拉勾教育看看大厂面试、热门技术分享直播，以及各类游戏直播。不知道你有没有思考过，我们每天看到的这么多音视频内容，是如何从采集端，最终呈现到我们的手机App上的？如果公司要提供直播服务，那么你可以出技术方案吗？为了应对这些应用场景，这一讲我们就以“直播网站是如何实现的”，来系统聊聊直播、点播、视频网站等基于流媒体技术的应用是怎么回事。流媒体在流媒体技
  • 2020年流媒体技术新发展 coding_myway StreamMedia流媒体音视频
    1、新一代视频编码标准正式公布MPEG本年度输出三项标准：(1)VersatileVideoCoding(VVC,H.266)；(2)EssentialVideoCoding(EVC,MPEG-5Part1)；(3)LowComplexityEnhancementVideoCoding(LCEVC,MPEG-5Part2)参考：【1】https://ottverse.com/vvc-evc-lce
  • 音视频领域的未来发展方向展望 码农飞飞 音视频音视频人工智能VR/AR流媒体语音识别
    文章目录音视频领域的未来发展方向全景音视频技术虚拟现实和增强现实的区别人工智能技术可视化智能分析智能语音交互图像识别和视频分析技术语音处理智能推荐技术远程实时通信流媒体技术未来方向音视频领域的未来发展方向全景音视频技术：全景音视频技术是近年来崛起的技术，它可以为用户营造更为真实的身临其境的视听体验。未来，全景音视频技术有可能成为音视频领域的重要发展方向，可以应用于娱乐、游戏、广告、培训等各个领域。
  • 解读Servlet原理篇二---GenericServlet与HttpServlet 周凡杨 javaHttpServlet源理GenericService源码
    在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
  • MySQL性能优化 bijian1013 数据库mysql
            性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有：         a.优化查询         b.优化数据库结构  
  • ThreadPool定时重试 dai_lm javaThreadPoolthreadtimertimertask
    项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。 由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。 为了解决不定间隔的重试，选择Timer和TimerTask来完成 package threadpool; public class ThreadPoolTest {
  • Oracle 查看数据库的连接情况 周凡杨 sqloracle 连接
    首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 select * from dict where table_name like '%SESSION%'; 就可以查出一些表，然后根据这些表就可以获得会话信息 select sid,serial#,status,username,schemaname,osuser,terminal,ma
  • 类的继承 朱辉辉33 java
    类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 格式:public class 类名（子类）extends 类名（父类）{ } 子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 protected属性，但要使用private属性仍需通过调用。 子类的方法可以重写，但必须和父类的返回值类
  • android 悬浮窗特效 肆无忌惮_ android
    最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下：   一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。   后来想利用Dialog的dismiss动画来完成。   自定义一个Dialog后，在styl
  • hadoop伪分布式搭建 林鹤霄 hadoop
    要修改4个文件    1: vim hadoop-env.sh  第九行    2: vim core-site.xml            <configuration>     &n
  • gdb调试命令 aigo gdb
    原文：http://blog.csdn.net/hanchaoman/article/details/5517362   一、GDB常用命令简介   r run 运行.程序还没有运行前使用 c             cuntinue 
  • Socket编程的HelloWorld实例 alleni123 socket
    public class Client { public static void main(String[] args) { Client c=new Client(); c.receiveMessage(); } public void receiveMessage(){ Socket s=null; BufferedRea
  • 线程同步和异步 百合不是茶 线程同步异步
    多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。 所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法   多线程和异步:多线程可以做不同的事情,涉及到线程通知     &
  • JSP中文乱码分析 bijian1013 javajsp中文乱码
            在JSP的开发过程中，经常出现中文乱码的问题。         首先了解一下Java中文问题的由来：         Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
  • js实现页面跳转重定向的几种方式 bijian1013 JavaScript重定向
            js实现页面跳转重定向有如下几种方式： 一.window.location.href <script language="javascript"type="text/javascript"> window.location.href="http://www.baidu.c
  • 【Struts2三】Struts2 Action转发类型 bit1129 struts2
     在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下   <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configurat
  • 【HBase十一】Java API操作HBase bit1129 hbase
    Admin类的主要方法注释：   1. 创建表 /** * Creates a new table. Synchronous operation. * * @param desc table descriptor for table * @throws IllegalArgumentException if the table name is res
  • nginx gzip ronin47 nginx gzip
    Nginx GZip 压缩 Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 常用配置片段如下： gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
  • java-7.微软亚院之编程判断俩个链表是否相交 给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交 bylijinnan java
    public class LinkListTest { /** * we deal with two main missions: * * A. * 1.we create two joined-List(both have no loop) * 2.whether list1 and list2 join * 3.print the join
  • Spring源码学习-JdbcTemplate batchUpdate批量操作 bylijinnan javaspring
    Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 JDBC的batch操作： String sql = "INSERT INTO CUSTOMER " + "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
  • [JWFD开源工作流]大规模拓扑矩阵存储结构最新进展 comsci 工作流
        生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出.........     竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
  • base64编码和url编码 cuityang base64url
    import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.io.StringWriter; import java.io.UnsupportedEncodingException;
  • web应用集群Session保持 dalan_123 session
    关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
  • Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式'] dcj3sjt126com 数据库
        public function getMinLimit () {        $sql = "...";        $result = yii::app()->db->createCo
  • solr StatsComponent（聚合统计） eksliang solr聚合查询solr stats
    StatsComponent 转载请出自出处：http://eksliang.iteye.com/blog/2169134 http://eksliang.iteye.com/ 一、概述        Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能   二、参数
  • 百度一道面试题 greemranqq 位运算百度面试寻找奇数算法bitmap 算法
    那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5}  找出出现次数为奇数的数字.   我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。   还有人觉得应该用算法xxx,我是没想到用啥算法好...！   还有觉得应该先排序...   还有觉
  • Spring之在开发中使用SpringJDBC ihuning spring
      在实际开发中使用SpringJDBC有两种方式：   1. 在Dao中添加属性JdbcTemplate并用Spring注入；     JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
  • JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节 justjavac json
    2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
  • 网站项目建设流程概述 macroli 工作
    一.概念 网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。 二.需求分析 项目立项 　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。 客户的需求说明书 　　第一步是需
  • AngularJs 三目运算 表达式判断 qiaolevip 每天进步一点点学习永无止境众观千象AngularJS
    事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 var b = "{{", a = "}}"; this.startSymbol = function(a) {
  • Spark算子：统计RDD分区中的元素及数量 superlxw1234 sparkspark算子Spark RDD分区元素
    关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量     Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。   可以利用RDD的mapPartitionsWithInd
  • Spring 3.2.x将于2016年12月31日停止支持 wiselyman Spring 3
                  Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。          请大家及时准备及时升级到Spring
  • fis纯前端解决方案fis-pure zccst JavaScript
    作者：zccst FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 1，fis-pure的安装 $ fis install -g fis-pure $ pure -v 0.1.4 2，下载demo到本地 git clone https://github.com/hefangshi/f
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他