在嵌入式设备中实现webrtc的第三种方式③

　　本系列的最后一篇，讲解收发音视频数据。

　　贴出最终效果：

　　

　　其实很简单，直接调用writeFrame即可，如下图：

　　

 　　当然，这是部分代码，完整代码在下面，展开可见：

#include "com/amazonaws/kinesis/video/webrtcclient/Include.h"
#include "json/json.h"

#include "ws_client.h"

#include <iostream>
#include <thread>

static PRtcPeerConnection peer_;
static PRtcDataChannel dc_;
static PRtcRtpTransceiver videoTransceiver_;
static PRtcRtpTransceiver audioTransceiver_;
static WSClient *ws = nullptr;

STATUS readFrameFromDisk(PBYTE pFrame, PUINT32 pSize, PCHAR frameFilePath)
{
    STATUS retStatus = STATUS_SUCCESS;
    UINT64 size = 0;

    if (pSize == NULL) {
        printf("[KVS Master] readFrameFromDisk(): operation returned status code: 0x%08x 
", STATUS_NULL_ARG);
        goto CleanUp;
    }

    size = *pSize;

    // Get the size and read into frame
    retStatus = readFile(frameFilePath, TRUE, pFrame, &size);
    if (retStatus != STATUS_SUCCESS) {
        printf("[KVS Master] readFile(): operation returned status code: 0x%08x 
", retStatus);
        goto CleanUp;
    }

CleanUp:

    if (pSize != NULL) {
        *pSize = (UINT32) size;
    }

    return retStatus;
}

static void onWsData(const std::string& data, void* usrParam) {
  Json::Reader reader;
  Json::Value root;
  if (reader.parse(data, root)) {
    if(root["type"] == "answer") {
      RtcSessionDescriptionInit answer;
      Json::FastWriter writer;
      writer.omitEndingLineFeed();
      std::string _sdp_json_answer = writer.write(root);
      int ret = deserializeSessionDescriptionInit((PCHAR)_sdp_json_answer.data(), _sdp_json_answer.size(), &answer);
      std::cout << "deserializeSessionDescriptionInit:" << std::hex << ret << std::endl;
      std::cout << "answer:
" << answer.sdp << std::endl;
      if(ret == 0) {
        std::cout << "setRemoteDescription:" << std::hex << setRemoteDescription(peer_, &answer) << std::endl;
      }
    } else if (root["type"] == "candidate") {
      if(!root["candidate"].asString().empty()) {
        //std::cout << "addIceCandidate:" << addIceCandidate(peer_, "") << std::endl;
      //} else{
        RtcIceCandidateInit ice;
        Json::FastWriter writer;
        writer.omitEndingLineFeed();
        std::string _ice_json = writer.write(root);
        int ret = deserializeRtcIceCandidateInit((PCHAR)_ice_json.data(), _ice_json.size(), &ice);
        std::cout << "deserializeRtcIceCandidateInit:" << std::hex << ret << std::endl;
        if(ret == 0) {
          std::cout << "remote-ice:" << ice.candidate << std::endl;
          std::cout << "addIceCandidate:" << std::hex << addIceCandidate(peer_, ice.candidate) << std::endl;
        }
      }
    } else if(root["type"] == "hello") {

      RtcSessionDescriptionInit offer;
      std::cout << "createOffer:" << std::hex << createOffer(peer_, &offer) << std::endl;
      std::cout << "offer:
" << offer.sdp << std::endl;

      std::cout << "setLocalDescription:" << std::hex << setLocalDescription(peer_, &offer) << std::endl;

      char sdp_json[10240] = {0};
      unsigned int sdp_json_buf_len = sizeof sdp_json;
      std::cout << "serializeSessionDescriptionInit:" << std::hex << serializeSessionDescriptionInit(&offer, sdp_json, &sdp_json_buf_len) << std::endl;
      std::cout << "sdp_json_offer:
" << sdp_json << std::endl;

      ws->Send(sdp_json);
    }
  } else {
    std::cout << "Json parse failed" << std::endl;
  }
}

void func_RtcOnIceCandidate(UINT64 custmerData, PCHAR iceStr) {
  if(iceStr != nullptr && strlen(iceStr) > 0) {
    std::cout << "local-ice:" << iceStr << std::endl;
    Json::Value ice;
    Json::Reader reader;
    if(reader.parse(iceStr, ice)) {
      ice["type"] = "candidate";
      Json::FastWriter writer;
      writer.omitEndingLineFeed();
      std::string _ice_json = writer.write(ice);
      ws->Send(_ice_json);
    }
  }
}

void func_RtcOnMessage(UINT64 customData, PRtcDataChannel dc, BOOL isBinary, PBYTE msgData, UINT32 msgLen) {
  printf("func_RtcOnMessage dc_label=%s isBinary=%d msgLen=%d
", dc->name, isBinary, msgLen);
  if(!isBinary) {
    printf("	%.*s
", msgLen, msgData);
  }
}

void func_RtcOnConnectionStateChange(UINT64 customData, RTC_PEER_CONNECTION_STATE state) {
  if(state == RTC_PEER_CONNECTION_STATE::RTC_PEER_CONNECTION_STATE_CONNECTED) {
    RtcDataChannelInit dcInit;
    memset(&dcInit, 0, sizeof dcInit);
    dcInit.ordered = TRUE;
    std::cout << "createDataChannel:" << std::hex << createDataChannel(peer_, (PCHAR)"op", &dcInit, &dc_) << std::endl;
    std::cout << "dataChannelOnMessage:" << std::hex << dataChannelOnMessage(dc_, 0, func_RtcOnMessage) << std::endl;
    std::thread([]{
      int vidx = 6;
      char vfn[256] = {0};
      Frame frame = {0};
      char vbuffer[100 * 1024];
      frame.frameData = (PBYTE)vbuffer;
      STATUS retStatus = STATUS_SUCCESS;
      UINT64 startTime, lastFrameTime, elapsed;
      startTime = GETTIME();
      lastFrameTime = startTime;
      while(true) {
        sprintf(vfn, "/data_fs/h264s/%d.h264", vidx++);
        frame.size = sizeof vbuffer;
        retStatus = readFrameFromDisk(frame.frameData, &frame.size, vfn);
        if(retStatus != STATUS_SUCCESS) {
          std::cout << "readFrameFromDisk:" << std::hex << retStatus << std::endl;
          break;
        }
        frame.presentationTs += (((10LL * 1000LL) * 1000LL) / 25);
        retStatus = writeFrame(videoTransceiver_, &frame);
        if(retStatus != STATUS_SUCCESS) {
          if(retStatus == STATUS_SRTP_NOT_READY_YET) {
            //std::cout << "writeFrame(video):" << std::hex << retStatus << std::endl;
            vidx--;
          } else{
            std::cout << "writeFrame(video):" << std::hex << retStatus << std::endl;
            break;
          }
        }
        elapsed = lastFrameTime - startTime;
        std::this_thread::sleep_for(std::chrono::nanoseconds((((10LL * 1000LL) * 1000LL) / 25) - elapsed % (((10LL * 1000LL) * 1000LL) / 25)));
        lastFrameTime = GETTIME();
      }
    }).detach();
    std::thread([]{
      int aidx = 1;
      char afn[256] = {0};
      Frame frame = {0};
      char abuffer[100 * 1024];
      frame.frameData = (PBYTE)abuffer;
      STATUS retStatus = STATUS_SUCCESS;
      while(true) {
        sprintf(afn, "/data_fs/pcms/%d.pcma", aidx++);
        frame.size = sizeof abuffer;
        retStatus = readFrameFromDisk(frame.frameData, &frame.size, afn);
        if(retStatus != STATUS_SUCCESS) {
          std::cout << "readFrameFromDisk:" << std::hex << retStatus << std::endl;
          break;
        }
        frame.presentationTs += (20 * (10LL * 1000LL));
        retStatus = writeFrame(audioTransceiver_, &frame);
        if(retStatus != STATUS_SUCCESS) {
          if(retStatus == STATUS_SRTP_NOT_READY_YET) {
            //std::cout << "writeFrame(audio):" << std::hex << retStatus << std::endl;
            aidx--;
          } else{
            std::cout << "writeFrame(audio):" << std::hex << retStatus << std::endl;
            break;
          }
        }
        std::this_thread::sleep_for(std::chrono::nanoseconds((20 * (10LL * 1000LL))));
      }
    }).detach();
  }
}

void func_RtcOnFrame(UINT64 customData, PFrame frame) {
  printf("func_RtcOnFrame(audio) size=%d
", frame->size);
}

int main() {
  //printf("STATUS_ICE_CANDIDATE_INIT_MALFORMED %lu
", STATUS_ICE_CANDIDATE_INIT_MALFORMED);

  char wsUrl[64];  
  sprintf(wsUrl, "ws://192.168.0.44:8080/webrtc/channel/01239F-C8ADE4-630DEE");
  ws = new WSClient(wsUrl);

  ws->SetDataCb(onWsData, nullptr);
  if(!ws->Start()) return -1;

  initKvsWebRtc();

  RtcConfiguration conf_;
  memset(&conf_, 0, sizeof conf_);
  conf_.iceTransportPolicy = ICE_TRANSPORT_POLICY::ICE_TRANSPORT_POLICY_ALL;
  //conf_.kvsRtcConfiguration.generatedCertificateBits = 2048;
  conf_.kvsRtcConfiguration.generateRSACertificate = 1;
  strcpy(conf_.iceServers[0].urls, "stun:77.72.169.213:3478");
  std::cout << "createPeerConnection:" << std::hex << createPeerConnection(&conf_, &peer_) << std::endl;

  std::cout << "peerConnectionOnIceCandidate:" << std::hex << peerConnectionOnIceCandidate(peer_, 0, func_RtcOnIceCandidate) << std::endl;
  std::cout << "peerConnectionOnConnectionStateChange:" << std::hex << peerConnectionOnConnectionStateChange(peer_, 0, func_RtcOnConnectionStateChange) << std::endl;

  PRtcMediaStreamTrack video_track_ = new RtcMediaStreamTrack;
  memset(video_track_, 0, sizeof *video_track_);
  video_track_->codec = RTC_CODEC::RTC_CODEC_H264_PROFILE_42E01F_LEVEL_ASYMMETRY_ALLOWED_PACKETIZATION_MODE;
  video_track_->kind = MEDIA_STREAM_TRACK_KIND::MEDIA_STREAM_TRACK_KIND_VIDEO;
  strcpy(video_track_->streamId, "0");
  strcpy(video_track_->trackId, "0");
  RtcRtpTransceiverInit rtcRtpTransceiverInit_v_;
  rtcRtpTransceiverInit_v_.direction = RTC_RTP_TRANSCEIVER_DIRECTION::RTC_RTP_TRANSCEIVER_DIRECTION_SENDONLY;
  std::cout << "addTransceiver:" << std::hex << addTransceiver(peer_, video_track_, &rtcRtpTransceiverInit_v_, &videoTransceiver_) << std::endl;

  PRtcMediaStreamTrack audio_track_ = new RtcMediaStreamTrack;
  memset(audio_track_, 0, sizeof *audio_track_);
  audio_track_->codec = RTC_CODEC::RTC_CODEC_ALAW;
  audio_track_->kind = MEDIA_STREAM_TRACK_KIND::MEDIA_STREAM_TRACK_KIND_AUDIO;
  strcpy(audio_track_->streamId, "1");
  strcpy(audio_track_->trackId, "1");
  RtcRtpTransceiverInit rtcRtpTransceiverInit_a_;
  rtcRtpTransceiverInit_a_.direction = RTC_RTP_TRANSCEIVER_DIRECTION::RTC_RTP_TRANSCEIVER_DIRECTION_SENDRECV;
  std::cout << "addTransceiver:" << std::hex << addTransceiver(peer_, audio_track_, &rtcRtpTransceiverInit_a_, &audioTransceiver_) << std::endl;
  std::cout << "transceiverOnFrame:" << std::hex << transceiverOnFrame(audioTransceiver_, 0, func_RtcOnFrame) << std::endl;

  while(true) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
  }
  deinitKvsWebRtc();

  return -1;
}

　　由于上一篇文章已经把项目发出来了，因此这里就没有再发，这个文件替换即可。

　　（发h264时，就是每个nal发一次，当然了，一般I帧前头带着SPS/PPS，好像行业内的编码器都是这样，是可以的。pcma的话就是160一段；我是8K的，50Hz）

　　收数据就是transceiverOnFrame注册的回调，代码中也有，但我暂时没有从h5获取，因为我电脑也没有mic。

　　资源文件如下：

　　

　　(pcm我没录到，因为录音设备没有mic，这边算是一个互动，大家自己动手试试)

　　

 　　

　　That's all.

　　

　　有高手希望指点的话可以通过微信与我联系，我的id是wxid_8r2mjkbcu2an22

 　　最后修改时间 2020-11-09 11:30:08