eventstream挖礦
Ⅰ flex錯誤：Error #2044: 未處理的NetStatusEvent是怎麼回事
用red5做一個錄像程序時，前台的flex一直報這個錯，完整的錯誤信息是：Error #2044: 未處理的 NetStatusEvent:。 level=error, code=NetStream.Record.NoAccess at myWebSite/netStatus()[C:\Users\ASUS\Adobe Flash Builder 4\myWebSite\src\myWebSite.mxml:23]myWebSite.mxml的第23行是netStream=new NetStream(conn);這個錯誤是在方法：private function netStatus(e:NetStatusEvent):void{ trace(e.info.code); if(e.info.code=="NetConnection.Connect.Success"){ isConnectSuccess=true; netStream=new NetStream(conn); netStream.client=new StreamClient(); netStream.attachAudio(Microphone.getMicrophone()); netStream.attachCamera(Camera.getCamera()); state.text="已經開始錄像";}}中報的，netStream=new NetStream(conn);就是報錯的行。這個函數是作為連接時的回調函數：conn.addEventListener(NetStatusEvent.NET_STATUS,netStatus);
Ⅱ win7怎樣使用kernel streaming
內核流(Kernel Streaming)驅動模型在多媒體方面應用的比較多，支持內核流模型的驅動能夠
向系統報告它的性能，以及能夠將數據高效，通用的傳遞。通俗的說，就是可以將攝像頭的數據直接傳遞到顯卡中顯示，而不需要通過應用層.它可以避免數據在應用層和內核層之間的傳遞，但是這對於上層來說是透明的；並且採用WDM 內核流模型還可以實現設備無關性，使得程序有很好的移植性和通用性。一般來說，QQ攝像頭就是使用基於WDM內核流的組件來實現的。所以可以在打開攝像頭的時候輕易的更換為給對方播放影音文件(在上層使用相同的組件和流程，僅僅更換了source filter)。在這里需要指明的是，minidriver一般是可以和硬體設備相關，但是也不一樣會和硬體設備相關，它在內核層同樣可以調用其他的組件，例如可以實現虛擬攝像頭之類的應用。
一般來說，硬體設備會提供一個KsProxy組件，這個組件能夠完成一些相應的擴展功能，同時，也可以將數據進行不同類別的傳送。上層應用程序能夠控制底層數據的流向，而不是將數據拷貝到應用層，然後再傳遞給內核層處理(這個和DirectX的處理有相似的地方，因為DirectShow曾經也是DirectX的一員)。
雖然現在微軟對於流內核結構進行了調整，新的流類型採用的是AVStream(下一次在敘述AVStream框架)。但是從目前來看，很多情況下仍然採用目前的方式來處理數據。
下面通過源代碼和數據類型的形式來講解一下這個驅動程序的框架結構。會盡量屏蔽代碼中關於具體設備的細節，專注於描述stream class的流程和結構:
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1. 驅動程序的入口點:
NTSTATUS DriverEntry(__in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING
RegistryPath)
{
HW_INITIALIZATION_DATA HwInitData;
RtlZeroMemory( &HwInitData, sizeof(HW_INITIALIZATION_DATA) );
HwInitData.HwInitializationDataSize = sizeof(HwInitData); // 結構大小
HwInitData.HwInterrupt = NULL; // 硬體回調
HwInitData.HwReceivePacket = MyReceivePacket; // 控制回調
HwInitData.HwCancelPacket = MyCancelOnePacket; // 取消回調
HwInitData.HwRequestTimeoutHandler = MyTimeoutHandler; // 超時回調
HwInitData.DeviceExtensionSize = sizeof(MY_EXTENSION); // 設備擴展
HwInitData.PerStreamExtensionSize = sizeof(STREAMEX); // 流擴展
HwInitData.PerRequestExtensionSize = sizeof(IRB); // SRB大小
HwInitData.FilterInstanceExtensionSize = 0; // 安裝大小
HwInitData.BusMasterDMA = FALSE; // 匯流排DMA
HwInitData.Dma24BitAddresses = FALSE; // DMA地址
HwInitData.BufferAlignment = sizeof(ULONG) - 1; //
HwInitData.TurnOffSynchronization = TRUE;
HwInitData.DmaBufferSize = 0;
// 注冊流埠驅動和回調函數
return (StreamClassRegisterAdapter(DriverObject, RegistryPath, &HwInitData));
}
這里可以看得出，驅動入口點基本上只是向stream class注冊回調函數和信息。此處的設備
擴展和流擴展需要我們自己定義。
超時回調函數和取消回調函數本身並沒有做太過於特殊的事情，關鍵在於控制命令回調函數，它是接收上層，也就是stream class 發送的控制包，下面會詳細的講解控制命令回調函數:
2. MyReceivePacket函數:
VOID
MyReceivePacket(IN PHW_STREAM_REQUEST_BLOCK pSrb)
{
PIO_STACK_LOCATION IrpStack;
PMY_EXTENSION pDevExt = (PMY_EXTENSION) pSrb->HwDeviceExtension;
PAGED_CODE();
pSrb->Status = STATUS_SUCCESS;
switch (pSrb->Command) {
case SRB_INITIALIZE_DEVICE: // 初始化設備
break;
case SRB_INITIALIZATION_COMPLETE: // 初始化設備完成
break;
case SRB_GET_STREAM_INFO:// 獲取設備信息
break;
case SRB_OPEN_STREAM: // 打開流
break;
case SRB_CLOSE_STREAM: // 關閉流
break;
case SRB_SURPRISE_REMOVAL: // 移除設備
break;
case SRB_UNKNOWN_DEVICE_COMMAND: // 未知的命令
break;
case SRB_UNINITIALIZE_DEVICE: // 卸載設備
break;
case SRB_GET_DATA_INTERSECTION: // 獲取格式和范圍
break;
case SRB_CHANGE_POWER_STATE: // 改變電源狀態
break;
case SRB_GET_DEVICE_PROPERTY: // 獲取設備屬性
break;
case SRB_SET_DEVICE_PROPERTY: // 設置設備屬性
break;
case SRB_PAGING_OUT_DRIVER: // ？
break;
default:
pSrb->Status = STATUS_NOT_IMPLEMENTED;
break;
}
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension,
pSrb);
}
可以看出來的是，上層會通過向這個函數發送命令包，來控制設備的行為。這個埠驅動需要
自己決定從什麼拷貝來數據，或者怎麼向上層回復。
這里stream class的命令中，需要關注地方並不多，由於設備可能會是USB設備/1394設備/網路
組件/圖像採集卡，所以很難統一的給出一份具體的代碼.但是通過下面的幾個命令的講解，大家
應該很容易的構建出具體設備的代碼來:
2.1 初始化命令: 在設備的初始化階段，stream class 會依次發送下面的命令
SRB_INITIALIZE_DEVICE->SRB_GET_STREAM_INFO->SRB_INITIALIZATION_COMPLETE
一般來說，SRB_INITIALIZE_DEVICE命令主要是初始化設備擴展和屬性結構的初始化，
SRB_GET_STREAM_INFO命令則是向注冊表寫入自己的屬性，並提供相應的另一組回調函數給
Stream class，便於接受更微觀的控制;SRB_INITIALIZATION_COMPLETE命令一般是一個完成回調
的方式。
下面的代碼會揭示在SRB_GET_STREAM_INFO命令時候,一般會進行的處理:
typedef struct _HW_STREAM_HEADER {
ULONG NumberOfStreams; // 支持的流的數目
ULONG SizeOfHwStreamInformation; // 結構大小
ULONG NumDevPropArrayEntries; // 支持的屬性數組大小
PKSPROPERTY_SET DevicePropertiesArray; // 屬性數組
ULONG NumDevEventArrayEntries; // 支持的事件數組大小
PKSEVENT_SET DeviceEventsArray; // 事件數組
PKSTOPOLOGY Topology; //
PHW_EVENT_ROUTINE DeviceEventRoutine; // 超時時間
ULONG Reserved[2]; // 保留
} HW_STREAM_HEADER, *PHW_STREAM_HEADER;
typedef struct _HW_STREAM_INFORMATION {
ULONG NumberOfPossibleInstances; // 設備支持的流的數量
KSPIN_DATAFLOW DataFlow; // 數據流的方向
BOOLEAN DataAccessible; // 數據釋放是否能夠被看到
ULONG NumberOfFormatArrayEntries; // 支持的屬性信息
PKSDATARANGE* StreamFormatsArray; // 屬性信息數組
PVOID ClassReserved[4];
ULONG NumStreamPropArrayEntries; // 流媒體的支持屬性數組的下標
PKSPROPERTY_SET StreamPropertiesArray;// 屬性數組
ULONG NumStreamEventArrayEntries;
PKSEVENT_SET StreamEventsArray;
GUID* Category; // Pin范圍
GUID* Name; // Pin的名字
ULONG MediumsCount;
const KSPIN_MEDIUM* Mediums; // 媒體類型
BOOLEAN BridgeStream; // 允許流進行橋接？
ULONG Reserved[2];
} HW_STREAM_INFORMATION, *PHW_STREAM_INFORMATION;
VOID MyGetStreamInfo(IN PHW_STREAM_REQUEST_BLOCK Srb)
{
PHW_STREAM_HEADER StreamHeader = &(Srb->CommandData.StreamBuffer->StreamHeader);
PMY_EXTENSION pDevExt = (PMY_EXTENSION) Srb->HwDeviceExtension;
PHW_STREAM_INFORMATION StreamInfo = &(Srb->CommandData.StreamBuffer->StreamInfo);
PAGED_CODE();
ASSERT (Srb->NumberOfBytesToTransfer >=
sizeof (HW_STREAM_HEADER) +
sizeof (HW_STREAM_INFORMATION));
RtlZeroMemory(StreamHeader,
sizeof (HW_STREAM_HEADER) +
sizeof (HW_STREAM_INFORMATION));
StreamHeader->NumberOfStreams = 1;
StreamHeader->SizeOfHwStreamInformation = sizeof(HW_STREAM_INFORMATION);
StreamHeader->NumDevPropArrayEntries = pDevExt->ulPropSetSupported;
StreamHeader->DevicePropertiesArray = &pDevExt->VideoProcAmpSet;
StreamInfo->NumberOfPossibleInstances = 1;
StreamInfo->DataFlow = KSPIN_DATAFLOW_OUT;
StreamInfo->DataAccessible = TRUE;
StreamInfo->NumberOfFormatArrayEntries = pDevExt->ModeSupported;
StreamInfo->StreamFormatsArray = &pDevExt->MyStrmModes[0];
StreamInfo->NumStreamPropArrayEntries = NUMBER_VIDEO_STREAM_PROPERTIES;
StreamInfo->StreamPropertiesArray = (PKSPROPERTY_SET) VideoStreamProperties;
StreamInfo->Name = (GUID *) &PINNAME_VIDEO_CAPTURE;
StreamInfo->Category = (GUID *) &PINNAME_VIDEO_CAPTURE;
Srb->CommandData.StreamBuffer->StreamHeader.Topology = &Topology;
Srb->Status = STATUS_SUCCESS;
}
2.2 打開和關閉流: SRB_OPEN_STREAM/SRB_CLOSE_STREAM 命令，此處需要注意的就是一個協商的
過程了，因為此處上層和下層需要來協商進行哪種數據類型的傳遞。
下面的代碼片段屏蔽了硬體的具體相關細節，主要描述和stream class相關的部分:
VOID MyOpenStream(IN PHW_STREAM_REQUEST_BLOCK pSrb)
{
PIRB Irb;
ULONG nSize;
PMY_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
PKS_DATAFORMAT_VIDEOINFOHEADER pKSDataFormat =
(PKS_DATAFORMAT_VIDEOINFOHEADER) pSrb->CommandData.OpenFormat;
PKS_VIDEOINFOHEADER pVideoInfoHdrRequested =
&pKSDataFormat->VideoInfoHeader;
PAGED_CODE();
Irb = (PIRB) pSrb->SRBExtension;
pDevExt = (PMY_EXTENSION) pSrb->HwDeviceExtension;
pStrmEx = (PSTREAMEX)pSrb->StreamObject->HwStreamExtension;
// 緩存流擴展
pDevExt->pStrmEx = pStrmEx;
pSrb->Status = STATUS_SUCCESS;
// 確定哪些編號流被打開了。這些編號表明在流信息結構的偏移數組中被調用的
// 流信息適配器
//
// So:
// 0 - Video data from camera
//
// 0 - 從硬體出來的視頻數據
switch (pSrb->StreamObject->StreamNumber) {
case 0:
// 檢查設備是否在使用
// 找出格式,他們正試圖打開第一格式，此處一般採用的是循環對比的方式
// 來找到合適的媒體類型。
if (!AdapterVerifyFormat (pDevExt->ModeSupported, pDevExt->MyStrmModes, pKSDataFormat, pSrb->StreamObject->StreamNumber)) {
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
// 初始化流擴展
InitializeStreamExtension(pDevExt, pSrb->StreamObject, pStrmEx);
// 使用我們的安全版本
if (!NT_SUCCESS(RTL_SAFE_KS_SIZE_VIDEOHEADER(pVideoInfoHdrRequested, &nSize))) {
pSrb->Status = STATUS_INTEGER_OVERFLOW;
return;
}
pStrmEx->pVideoInfoHeader = ExAllocatePoolWithTag(NonPagedPool, nSize, 'macd');
if (pStrmEx->pVideoInfoHeader == NULL) {
ASSERT(pStrmEx->pVideoInfoHeader != NULL);
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_INSUFFICIENT_RESOURCES;
return;
}
// 拷貝媒體信息頭
RtlCopyMemory(
pStrmEx->pVideoInfoHeader,
pVideoInfoHdrRequested,
nSize);
// 分配硬體需要的資源
pSrb->Status = MyAllocateIsochResource(pDevExt, pSrb->SRBExtension, TRUE);
if (pSrb->Status) {
ExFreePool(pStrmEx->pVideoInfoHeader);
pStrmEx->pVideoInfoHeader = NULL;
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_INSUFFICIENT_RESOURCES;
return;
}
// 提交控制回調/數據回調函數
pSrb->StreamObject->ReceiveDataPacket = (PHW_RECEIVE_STREAM_DATA_SRB) MyReceiveDataPacket;
pSrb->StreamObject->ReceiveControlPacket = (PHW_RECEIVE_STREAM_CONTROL_SRB) MyReceiveCtrlPacket;
if(pDevExt->bDevRemoved || pDevExt->bStopIsochCallback) {
pDevExt->bStopIsochCallback = FALSE;
pDevExt->bDevRemoved = FALSE;
}
// 初始化流擴展句柄信息
break;
default:
ASSERT(FALSE);
pDevExt->pStrmEx = NULL;
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pSrb->StreamObject->HwClockObject.ClockSupportFlags = 0;
// 我們不使用DMA方式
pSrb->StreamObject->Dma = FALSE;
pSrb->StreamObject->StreamHeaderMediaSpecific = sizeof(KS_FRAME_INFO);
// PIO 必須設置為mini驅動緩沖區使用邏輯定址，我們不打算控制這部分緩沖區
pSrb->StreamObject->Pio = FALSE;
// 將最後保存配置
(pDevExt, (PIRB) pSrb->SRBExtension);
ASSERT(pSrb->Status == STATUS_SUCCESS);
}
VOID MyCloseStream(IN PHW_STREAM_REQUEST_BLOCK pSrb)
{
PMY_EXTENSION pDevExt;
PSTREAMEX pStrmEx;
PIRB pIrb;
PAGED_CODE();
pSrb->Status = STATUS_SUCCESS;
pDevExt = (PMY_EXTENSION) pSrb->HwDeviceExtension;
ASSERT(pDevExt);
// 等待所有的未決工作完成
KeWaitForSingleObject( &pDevExt->PendingWorkItemEvent, Executive, KernelMode, FALSE, NULL );
pStrmEx = (PSTREAMEX)pDevExt->pStrmEx;
ASSERT(pStrmEx);
if(!pStrmEx ) {
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
return;
}
// pDevExt->Irb可能被釋放了，在HwUninitialize()中
// 由於某個原因，所以必須使用下面的
pIrb = (PIRB) pSrb->SRBExtension;
// 保存設備擴展信息
MySetPropertyValuesToRegistry(pDevExt);
// 釋放硬體資源
MyFreeIsochResource (pDevExt, pIrb, TRUE);
if(pStrmEx->pVideoInfoHeader) {
ExFreePool(pStrmEx->pVideoInfoHeader);
pStrmEx->pVideoInfoHeader = NULL;
}
pStrmEx->hMasterClock = 0;
// 如果輸入讀，那麼取消掉它們
if(pDevExt->PendingReadCount > 0) {
if( InterlockedExchange((PLONG)&pStrmEx->CancelToken, 1 ) == 0 ) {
MyCancelAllPackets(
pDevExt,
&pDevExt->PendingReadCount
);
}
}
pDevExt->pStrmEx = 0;
StreamClassDeviceNotification(DeviceRequestComplete, pSrb->HwDeviceExtension, pSrb);
}
2.3 屬性設置: 屬性設置這一部分實際上都是通過特定的屬性表來實現的，它和硬體的相關性很大，一般採用DEFINE_KSPROPERTY_TABLE宏來實現對於屬性的封裝，這一部分可以查閱相應的資料即可實現。
Ⅲ stream和streamBuffer的區別
buffer
為數據緩沖對象，是一個類似數組結構的對象，可以通過指定開始寫入的位置及寫入的數據長度，往其中寫入二進制數據
stream
是對buffer對象的高級封裝，其操作的底層還是buffer對象，stream可以設置為可讀、可寫，或者即可讀也可寫，在nodejs中繼承了EventEmitter介面，可以監聽讀入、寫入的過程。具體實現有文件流，httpresponse等
Ⅳ 事件流是什麼
事件流也叫數據流。數據流最初是通信領域使用的概念，代表傳輸中所使用的信息的數字編碼信號序列。然而，我們所提到的數據流概念與此不同。這里提到的數據流具有以下兩個特點能夠持續產生大量的數據這類數據最早出現與傳統的銀行和股票交易領域，也在互聯網監控、無線通信網等領域出現、需要以近實時的方式對更新數據流進行復雜分析如趨勢分析、預測、監控等。事件流處理是數據流處理的一個子集，是一種特定的數據流處理。事件流處理與一般的數據流處理不同的是事件流處理通常是非同步的，事件可能源自不同的地方，而且類型也可能各異，接收的順序也可能差異很大。事件流處理需要使用事件屬性、事件發生的時間以及事件中任何能推斷的因果關系作為它的基礎元素。事件流模型相對於傳統靜態數據處理模型主要有如下幾方面的特徵：
1、事件流中的事件元素在線到達；
2、系統無法控制將要處理的新到達的事件元素的順序；
3、事件流模型中查詢是相對靜止不變的，而數據是時刻變化的；
4、從理論上說，事件流的潛在大小是無界的；系統能存儲的數據相對事件流的大小則是非常有限的；
5、一旦事件流中的某個元素經過處理，要麼被丟棄，要麼被歸檔存儲。但被丟棄的事件元素可能需要再次被訪問。
Ⅳ 請各位java師哥師姐:"救命啊!救命啊!"急急急!
public static void main(int k, int[][] a) {
int n = 1;
for (int i = 1; i <= k; i++)
n *= 2;
for (int i = 1; i <= n; i++)
a[1][i] = i;
int m = 1;
for (int s = 1; s <= k; s++) {
n /= 2;
for (int t = 1; t <= n; t++)
for (int i = m + 1; i < 2 * m; i++)
for (int j = m + 1; j <= 2 * m; j++) {
a[i][j + (t - 1) * m * 2] = a[i - m][j + (t - 1) * m
* 2 - m];
a[i][j + (t - 1) * m * 2 - m] = a[i - m][j + (t - 1)
* m * 2];
m *= 2;
}
}
System.out.println("你輸入了數字" + k);
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= n - 1; j++)
System.out.println(a[i][j]);
}
程序我給你改完了,把這個加你的類里就行了,我就那悶你的兩個for 循環里怎以都沒定義變數呀。
Ⅵ java rtpstream怎麼用
1.出現Local Data AddressDoes not belong to any of this hosts local interfaces錯誤：
主要問題是發送視頻和音頻的程序需要在伺服器上運行，你可以選擇Win2000 Server 或者Win2003 Server，問題就解決了。
2.傳輸聲音和視頻的方法如下：
a.傳輸聲音或者視頻文件
編譯完AVTransmit2.java後，再命令提示符中輸入命令：java AVTransmit2 file:test.wav 224.224.123.123 22222（注意文件的類型是.wav 或者.mov 、.mpg的文件，不可以是.mp3、.rmvb等其他不支持的文件。傳輸支持文件格式有限，我也沒有辦法，應該在添加相關的插件就行了，希望大家提供幫助），其中test.wav即傳輸的文件名，224.224.123.123為多播地址，22222為埠號.
接收方法:編譯完AVReceive.java後，在命令提示符中輸入命令:java AVReceive 224.224.123.123/22222即可接受到聲音文件
b.傳輸麥克風的音頻，在傳輸之前先檢查電腦錄音控制的選項是否為麥克風.（步驟：打開桌面任務欄上的音量控制，選擇選項---->屬性----->調節音量選擇錄音，之後在下面的音量控制屬性中選中麥克風。單擊確定。接著跳到錄音控制，選擇麥克風就行了)。使用的命令是：java AVTransmit2 dsound:// 224.224.123.123 22222，此時就開始傳輸聲音了。
接收方法同上
c.傳輸攝相頭視頻，使用的命令為：java AVTransmit2 vfw://0 224.224.123.123 22222
接收方法同上
d.關於廣播、組播和單播
廣播：對於區域網廣播你可以使用廣播的地址，如你的子網掩碼是255.255.225.0，即C類的默認子網掩碼，你的廣播地址可以是192.168.3.255。（註：我的區域網ip地址分配為192.168.3.X)。如子網掩碼不同，你可以參照相關的網路常識自己推算。
接收時也使用多播地址來接受，假如發送方的機器地址為：192.168.3.46。發送時在發送放的機器上運行java AVTransmit2 file:test.wav 192.168.3.255 22222，接收時使用java AVReceive2 224.224.123.123 22222。才能完成接收.這和網上的說法不同，埠號不要填錯，地址任意。按網上的說法，使用的接收地址應為為192.168.3.46，可是我沒有成功，總是出現Local Data AddressDoes not belong to any of this hosts local interfaces的錯誤，而使用多播地址反而成功了。具體的參數我就不多介紹了，有問題可以給我留言。
組播：使用組播地址發送，組播地址接收即可
單播：假如你只想給某台機子發送，那麼就在發送方輸入命令，如:java AVTransmit2 file:test.wav 192.168.3.47 22222，這時你只會將聲音流文件發送給47號計算機。而接受時還是使用多播地址，如java AVReceive2 224.224.123.123 22222。這是就聽到聲音了。
總之，使用RTP傳輸，在接受時都在使用多播地址，在發送時根據情況而定，至於ttl你可以不去管它。不只大家是怎麼實現的，反正網上的資料讓我變的很失望，真正的成功源於實踐。下面摘取一段讓大家欣賞（盡信書則不如無書)
網上摘取：
Transmitting Audio and Video over RTP
The AVTransmit2 class is very similar to the VideoTransmit, but uses RTP managers
to send the video and audio streams.
Since the media tracks are transmitted in multiple sessions, you'll need to
use one Player per track on the receive side. Using JMStudio, you can
start multiple Players from the "File" menu using the "New Window"
item. Then either:
use the "Open URL..." item to open one RTP session per track. The URL to use is:
rtp://<sourceIP>:<port>/media
Where <sourceIP> is the IP address of the RTP session and the port
number is the same one that is used on the transmitting side.
OR
Open RTP session and specify <sourcIP> and <port>
How to run this sample
1. Run AVTransmit2 with the required 3 command line parameters
For example, we can use any of the following:
- java AVTransmit2 file:clips/clip01mpg.mpg 224.112.112.112 22222
2. To receive the transmission on the client side use JMStudio:
- use open RTP session and specify group: 224.112.112.112 & port: 22222
AND use FILE -> New Window and open RTP sesssion with port 22224.
OR
- use open URL and specify: rtp://224.112.112.112:22222/video
AND use FILE -> New Window and open URL with 22224/audio
Notes:
You should run 1. then 2., otherwise AVTransmit2 will find the port number used.
You can also use the program to send only audio or video as follows:
- java AVTransmit2 javasound://0 224.112.112.112 22222 (audio only)
- java AVTransmit2 vfw://0 224.112.112.112 22222 (video only)
In such case create only one instance of JMStudio.
Use Unicast:
- java AVTransmit2 file:clip01.mpg 128.82.4.7 22222
Where 128.82.4.7 is the receicver address.
If the sender address is 128.82.4.9 it will use port 22222 as well
to send out data. In this case the receiver (e.g., JMStudio)
should specify the sender as: 128.82.4.9 22222.
Therefore to use unicast you should have two machines since
you can not use the same port for both sender and receiver.
Receiving Audio and Video using RTP
AVReceive2 uses the RTPManager API to receive RTP transmissions.
AVReceive2 performs the following tasks:
Open one RTP session per session address given.
Listen for the NewReceiveStreamEvent from the ReceiveStreamListener.
Create a JMF Player for each stream received for playback.
This sample program can be used in conjunction with JMStudio,
the AVTransmit2 sample or any other RTP compliant transmitter.
The IP address should be the address of the computer which transmits the data; or the multicast address if multicast is being used for the transmission.
The ports should be the same as what's being used by the transmitter.
How to run this sample
1. Run AVTransmit2 with the required 3 command line parameters
For example:
- java AVTransmit2 file:clips/clip01mpg.mpg 224.112.112.112 1234
2. Run AVReceive2 and specify the RTP session addresses to receive from.
For example:
- java AVReceive2 224.112.112.112/1234 224.112.112.112/1236
to simultaneously receive 2 different RTP sessions (video and audio).
Note: because of port reuse, it must run in this order, 1 then 2.
Ⅶ 獲取的網頁的stream轉為string有什麼方便的方法
Byte[] pageData = MyWebClient.DownloadData(tbUrl.Text); //從指定網站下載數據
string pageHtml = Encoding.Default.GetString(pageData); //把位元組轉化為字元串，注意編碼方式
2、使用WebBrowser控制項
//通過WebBrowser空間訪問網頁，然後獲取網頁數據
WebBrowser web = new WebBrowser();
web.Navigate(tbUrl.Text);
web.DocumentCompleted += new (web_DocumentCompleted); //當網頁載入完成時觸發該事件，獲取網頁數據
void web_DocumentCompleted(object sender, e){//獲取該html頁面內的Table標簽的內容
WebBrowser web = (WebBrowser)sender;
HtmlElementCollection ElementCollection = web.Document.getElementsByTagName_r("Table");
foreach (HtmlElement item in ElementCollection) {
textBox1.AppendText(item.InnerText + "\n");} }3、使用HttpWebRequest/HttpWebResponse
HttpWebRequest httpReq;
HttpWebResponse httpResp;
Uri httpURL = new Uri(this.tbUrl.Text);
httpReq = (HttpWebRequest)WebRequest.Create(httpURL);
httpResp = (HttpWebResponse)httpReq.GetResponse();
Stream respStream = httpResp.GetResponseStream(); //得到數據流，再把數據流轉化為特定的數據（圖片，文本。。。）
謝謝親~
Ⅷ 請教關於TcpClient的問題
TcpClient myClient;
Byte[] RecvBuffer = new Byte[1024];
用開始非同步接受數據
myClient.GetStream().BeginRead(RecvBuffer, 0, 1024, new AsyncCallback(GetCommand), null);
private void GetCommand(IAsyncResult ar)
{
int intCount;
try
{
//Lock the Client Stream
lock (myClient.GetStream())
{
//Receive the Bytes
intCount = myClient.GetStream().EndRead(ar);
}
if (intCount < 1)
{
//If a value less than 1 received that means that
//client disconnected
myClient.Close();
//raise the Disconnected Event
}
//Do Something to Do with the Packet
}
//Restart
lock (myClient.GetStream())
{
myClient.GetStream().BeginRead(RecvBuffer, 0, 1024, new AsyncCallback(GetCommand), null);
}
}
catch (Exception ex)
{
}
}
這樣就可以不斷接收
Ⅸ 如何執行超時 / NSStream，有效地使方法同步等待
我有一個輸入的流和輸出流的藍牙連接配件
我想要實現以下目標：
寫入數據到 outputStream 等待，直到收到對題目： 下面的數據或直到 10 秒傳遞如果題目： 下面數據到達其他返回數據返回零
我試著所以執行此類似：
- (APDUResponse *)sendCommandAndWaitForResponse:(NSData *)request {
APDUResponse * result;
if (!deviceIsBusy && request != Nil) {
deviceIsBusy = YES;
timedOut = NO;
responseReceived = NO;
if ([[mySes outputStream] hasSpaceAvailable]) {
[NSThread detachNewThreadSelector:@selector(startTimeout) toTarget:self withObject:nil];
[[mySes outputStream] write:[request bytes] maxLength:[request length]];
while (!timedOut && !responseReceived) {
sleep(2);
NSLog(@"tick");
}
if (responseReceived && response !=nil) {
result = response;
response = nil;
}
[myTimer invalidate];
myTimer = nil;
}
}
deviceIsBusy = NO;
return result;
}
- (void) startTimeout {
NSLog(@"start Timeout");
myTimer = [NSTimer timerWithTimeInterval:10.0 target:self selector:@selector(timerFireMethod:) userInfo:nil repeats:YES];
[[NSRunLoop currentRunLoop] addTimer:myTimer forMode:NSRunLoopCommonModes];
}
- (void)timerFireMethod:(NSTimer *)timer {
NSLog(@"fired");
timedOut = YES;
}
- (void)stream:(NSStream*)stream handleEvent:(NSStreamEvent)streamEvent
{
switch (streamEvent)
{
case :
// Process the incoming stream data.
if(stream == [mySes inputStream])
{
uint8_t buf[1024];
unsigned int len = 0;
len = [[mySes inputStream] read:buf maxLength:1024];
if(len) {
_data = [[NSMutableData alloc] init];
[_data appendBytes:(const void *)buf length:len];
NSLog(@"Response: %@", [_data description]);
response = [[APDUResponse alloc] initWithData:_data];
responseReceived = YES;
} else {
NSLog(@"no buffer!");
}
}
break;
... //code not relevant
}
}
所以理論是有 NSTimer 會設置一個布爾值時它射擊，然後 handleEvent 委託方法也有設置另一個 boolean 類型的值如果收到的數據的一個單獨的線程上運行。在方法中，我們有一段時間睡一覺，當這些 bool 之一設置時停止循環。
我遇到的問題在 '超時的情況下' 我的 timerFireMethod 不是是越來越叫。我的直覺是我是不實際正確設置計時器在一個單獨的線程上。
任何人都可以看看究竟怎麼在這里或建議的上述要求的更好實施嗎？
解決方法 1:
而是施加不當同步方法本質上非同步的問題，使您的方法 sendCommandAndWaitForResponse 非同步。
它是可能要包裝的"流寫入"任務為非同步操作/任務/方法。例如，你可能最終與並發子類的 NSOperation 與下面的介面：
typedef void (^DataToStreamCopier_completion_t)(id result);
@interface DataToStreamCopier : NSOperation
- (id) initWithData:(NSData*)sourceData
destinationStream:(NSOutputStream*)destinationStream
completion:(DataToStreamCopier_completion_t)completionHandler;
@property (nonatomic) NSThread* workerThread;
@property (nonatomic, ) NSString* runLoopMode;
@property (atomic, readonly) long long totalBytesCopied;
// NSOperation
- (void) start;
- (void) cancel;
@property (nonatomic, readonly) BOOL isCancelled;
@property (nonatomic, readonly) BOOL isExecuting;
@property (nonatomic, readonly) BOOL isFinished;
@end
您可以實現"超時"功能利用 cancel 方法。
您的方法 sendCommandAndWaitForResponse: 成為非同步完成處理程序：
- (void)sendCommand:(NSData *)request
completion:(DataToStreamCopier_completion_t)completionHandler
{
DataToStreamCopier* op = [DataToStreamCopier initWithData:request
destinationStream:self.outputStream
completion:completionHandler];
[op start];
// setup timeout with block: ^{ [op cancel]; }
...
}
用法:
[self sendCommand:request completion:^(id result) {
if ([result isKindOfClass[NSError error]]) {
NSLog(@"Error: %@", error);
}
else {
// execute on a certain execution context (main thread) if required:
dispatch_async(dispatch_get_main_queue(), ^{
APDUResponse* response = result;
...
});
}
}];
警告：
不幸的，執行並發 NSOperation 子類正常使用僱用一個運行的循環的基本任務不是那麼微不足道作為它應該是。那裡將會出現微妙的並發問題，迫使您可以使用同步基元像鎖或調度隊列和其他幾個技巧，使它真正可靠。
幸運的，換任何運行循環任務並發 NSOperation 子類基本上要求相同的"鍋爐板"代碼。所以，一旦你有一個通用的解決方案，了編碼的工作量是只是復制和粘貼從"模板"，然後為您的特定目的定製代碼。
替代的解決方案：
嚴格地說，你甚至不需要一個子類， NSOperation 如果你不打算放入這些任務數 NSOperationQueue 。可以簡單地將它發送入門並發操作 start 方法-有沒有 NSOperationQueue 所需。然後，不使用類的子類 NSOperation 可以使您自己的實現比較簡單，因為子類 NSOperation 本身有其自己微妙之處。
但是，你其實需要換行您運行循環駕駛"操作對象" NSStream 對象，因為執行需要保留狀態，不能在一個簡單的非同步方法完成。
因此，您可以使用任何自定義的類，可以查看作為非同步操作有 start 和 cancel 方法和有一種機制來通知調用站點完成基本任務。
也有更強大的手段來通知調用站點比完成處理程序。例如： 承諾或期貨 （見 wiki 文章期貨和承諾）。
假設作為一種手段，例如通知調用站點，實現您自己的"非同步操作"類的承諾：
@interface WriteDataToStreamOperation : AsyncOperation
- (void) start;
- (void) cancel;
@property (nonatomic, readonly) BOOL isCancelled;
@property (nonatomic, readonly) BOOL isExecuting;
@property (nonatomic, readonly) BOOL isFinished;
@property (nonatomic, readonly) Promise* promise;
@end
你原來的問題會更多"同步"-盡管正在非同步的窗檯：
您 sendCommand 方法將成為：
註：假定承諾類的某些實現：
- (Promise*) sendCommand:(NSData *)command {
WriteDataToStreamOperation* op =
[[WriteDataToStreamOperation alloc] initWithData:command
outputStream:self.outputStream];
[op start];
Promise* promise = op.promise;
[promise setTimeout:100]; // time out after 100 seconds
return promise;
}
註：承諾已設置"超時"。這基本上注冊一個計時器和一個處理程序。如果之前承諾的底層任務獲取解決激發計時器，計時器塊解析超時錯誤的諾言。如何 （和如果） 這實施取決於承諾圖書館。（在這里，我假設的 RXPromise 庫，我在哪裡作者。其他執行也可以實現這種功能）。
用法:
[self sendCommand:request].then(^id(APDUResponse* response) {
// do something with the response
...
return ...; // returns the result of the handler
},
^id(NSError*error) {
// A Stream error or a timeout error
NSLog(@"Error: %@", error);
return nil; // returns nothing
});
替代用法：
您可能會以不同的方式設置超時時間。現在，假設我們沒有設置超時時間內的 sendCommand: 方法。
我們可以設置"外部"超時：
Promise* promise = [self sendCommand:request];
[promise setTimeout:100];
promise.then(^id(APDUResponse* response) {
// do something with the response
...
return ...; // returns the result of the handler
},
^id(NSError*error) {
// A Stream error or a timeout error
NSLog(@"Error: %@", error);
return nil; // returns nothing
});
使非同步方法同步
通常，你不需要和不應該"轉換"的非同步方法的幾種同步方法在應用程序代碼中。這總是導致次優和效率低下的代碼不必要地消耗系統資源，線程類似。
然而，你可能會想要這樣做是有意義的單元測試中：
"同步"在單元測試中的非同步方法的示例
測試您的實施時, 經常要"等待"(是同步） 的結果。你基礎的任務實際上正在運行的循環，執行這一事實可能在相同的線程要等待結果的位置，不會使解決方案更簡單。
但是，您可以輕松完成此與 RXPromise 圖書館利用 runLoopWait 方法該方法有效地進入運行的循環並沒有等待解決的承諾：
-(void) {
Promise* promise = [self sendCommand:request];
[promise setTimeout:10];
[promise.then(^id(APDUResponse* response) {
// do something with the response
XCTAssertNotNil(response);
return ...; // returns the result of the handler
},
^id(NSError*error) {
// A Stream error or a timeout error
XCTestFail(@"failed with error: %@", error);
return nil; // returns nothing
}) runLoopWait]; // "wait" on the run loop
}
在這里，方法 runLoopWait 將輸入一個運行的循環，並等待的承諾得到解決，由一個超時錯誤或底層任務已解決承諾的時候。承諾將不會阻塞主線程和不輪詢運行的循環。它只是將留下運行的循環時承諾已得到解決。其他運行的循環事件將會像往常一樣處理。
註：您可以安全地調用 從主線程不會阻止它。而這是絕對必要的因為你流委託方法可能太在主線程上執行 ！
有其他方法通常在單元測試庫，其中提供類似的功能來非同步方法或操作，而進入運行的循環的結果"等待"中找到。
不建議使用其他方法以非同步方法或操作的最終結果為"等待"。這些通常會派遣到私人的線程的方法，然後阻止它，直到結果可用。
有用資源
操作像類，將流復制到另一個流利用的承諾 (上要點） 的代碼段： RXStreamToStreamCopier
Ⅹ 急求ATI-stream-sdk-v2.1-win7驅動，比特挖礦用的。。
推薦你在電腦上安裝驅動人生6，可以為你檢測電腦、列印機的硬體情況、系統環境以及驅動安裝情況，並為你推薦合適的驅動以及更新；
並提供下載和安裝，你根據提示進行操作即可
列印機可以通過區域網自動檢測安裝喲