示例#1
0
int cbOnPkt_silk(void *pUserData, const COLLECT_STREAM_PKTDATA_T *pPkt) {
  CAPTURE_CBDATA_SP_T *pSp = (CAPTURE_CBDATA_SP_T *) pUserData;
  const unsigned char *pData = pPkt ? pPkt->payload.pData : NULL;
  unsigned int len = pPkt ? PKTCAPLEN(pPkt->payload) : 0;
  CAPTURE_STORE_CBDATA_T cbData;
  int queueFr = 0;
  int rc = 0;

  if(pSp == NULL) {
    return -1;
  } else if(!pPkt || !pPkt->payload.pData) {
    // Packet was lost
    LOG(X_WARNING("RTP SILK lost packet, last seq:%u, last ts:%u"), pSp->lastPktSeq, pSp->lastPktTs);
    pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME | CAPTURE_SP_FLAG_PREVLOST);
    return 0;
  }

  VSX_DEBUG_RTP(
    LOG(X_DEBUG("RTP - rtp-recv-silk len:%d seq:%u ts:%u(%.3f) ts0:%u(%.3f, dlta:%.3f), mrk:%d ssrc:0x%x "
                   "flags:0x%x pQ:0x%x"),
       PKTCAPLEN(pPkt->payload), pPkt->u.rtp.seq, pPkt->u.rtp.ts, PTSF(pPkt->u.rtp.ts),
       pSp->pStream->ts0,
       (pSp->pStream->clockHz > 0 ? ((double)pSp->pStream->ts0/pSp->pStream->clockHz) : 0),
       (pSp->pStream->clockHz > 0 ? ((double)(pPkt->u.rtp.ts - pSp->pStream->ts0)/pSp->pStream->clockHz) : 0),
       (pPkt->u.rtp.marksz & PKTDATA_RTP_MASK_MARKER)?1:0,
       pSp->pStream->hdr.key.ssrc, pSp->spFlags, pSp->pCapAction && pSp->pCapAction->pQueue ? 1 : 0);
    if(pPkt && PKTCAPLEN(pPkt->payload) > 0) {
      LOGHEX_DEBUG(pPkt->payload.pData, MIN(16, PKTCAPLEN(pPkt->payload)));
    }
  );
示例#2
0
int cbOnPkt_vp8(void *pUserData, const COLLECT_STREAM_PKTDATA_T *pPkt) {
  int rc = 0;
  CAPTURE_CBDATA_SP_T *pSp = (CAPTURE_CBDATA_SP_T *) pUserData;
  CAPTURE_STORE_CBDATA_T cbData;
  int queueFr = 0;

  if(pSp == NULL) {
    return -1;
  } else if(!pPkt || !pPkt->payload.pData) {
    // Packet was lost
    LOG(X_WARNING("RTP VP8 lost packet, last seq:%u, last ts:%u"), pSp->lastPktSeq, pSp->lastPktTs);
    pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME | CAPTURE_SP_FLAG_PREVLOST);
    return 0;
  }

  VSX_DEBUG(
    //VSX_DEBUGLOG_TIME
    LOG(X_DEBUG("rtp-recv-vp8 len:%d seq:%u ts:%u(%.3f) ts0:%u(%.3f, dlta:%.3f), mrk:%d ssrc:0x%x "
                   "flags:0x%x pQ:0x%x"),
       PKTCAPLEN(pPkt->payload), pPkt->u.rtp.seq, pPkt->u.rtp.ts, PTSF(pPkt->u.rtp.ts),
       pSp->pStream->ts0,
       (pSp->pStream->clockHz > 0 ? ((double)pSp->pStream->ts0/pSp->pStream->clockHz) : 0),
       (pSp->pStream->clockHz > 0 ? ((double)(pPkt->u.rtp.ts - pSp->pStream->ts0)/pSp->pStream->clockHz) : 0),
       (pPkt->u.rtp.marksz & PKTDATA_RTP_MASK_MARKER)?1:0,
       pSp->pStream->hdr.key.ssrc, pSp->spFlags, pSp->pCapAction && pSp->pCapAction->pQueue ? 1 : 0);
    if(pPkt && PKTCAPLEN(pPkt->payload) > 0) {
      LOGHEX_DEBUG(pPkt->payload.pData, MIN(16, PKTCAPLEN(pPkt->payload)));
    }
    //fprintf(stderr, "tmpFrame.buf.idx:%d\n", pSp->pCapAction->tmpFrameBuf.idx);
  );
示例#3
0
int cbOnPkt_aac(void *pUserData, const COLLECT_STREAM_PKTDATA_T *pPkt) {
  CAPTURE_CBDATA_SP_T *pSp = (CAPTURE_CBDATA_SP_T *) pUserData;
  const unsigned char *pData = pPkt ? pPkt->payload.pData : NULL;
  unsigned int len = pPkt ? PKTCAPLEN(pPkt->payload) : 0;
  unsigned char adtsHdr[8];
  const ESDS_DECODER_CFG_T *pDecoderCfg;
  unsigned int numAuFrames;
  unsigned int idx;
  unsigned int payloadLen;
  unsigned int fragmentLen;
  unsigned int payloadStartIdx;
  uint32_t ts;
  CAPTURE_STORE_CBDATA_T cbData;
  int queueFr = 0;
  int rc = 0;


  //
  // TODO: pPkt ts, seq, ssrc, etc... are only set for RTP, if capture config is read
  // from SDP file - and goes through stream_net_av. (streaming capture eonly)
  // capture for recording and stream_net_pes uses deprecated way of queing raw 
  // network data for later depacketization, which calls this cb from the queue reader
  //

  if(pSp == NULL) {
    return -1;
  } else if(pData == NULL) {
    // Packet was lost
    LOG(X_WARNING("Lost AAC-hbr RTP packet"));
    pSp->spFlags &= ~CAPTURE_SP_FLAG_INFRAGMENT;
    return 0;
  }

  VSX_DEBUG_RTP(
    LOG(X_DEBUG("RTP - rtp-recv-aac len:%d seq:%u ts:%u(%.3f) ts0:%u(%.3f, dlta:%.3f), mrk:%d ssrc:0x%x "
                   "flags:0x%x pQ:0x%x"),
       PKTCAPLEN(pPkt->payload), pPkt->u.rtp.seq, pPkt->u.rtp.ts, PTSF(pPkt->u.rtp.ts),
       pSp->pStream->ts0,
       (pSp->pStream->clockHz > 0 ? ((double)pSp->pStream->ts0/pSp->pStream->clockHz) : 0),
       (pSp->pStream->clockHz > 0 ? ((double)(pPkt->u.rtp.ts - pSp->pStream->ts0)/pSp->pStream->clockHz) : 0),
       (pPkt->u.rtp.marksz & PKTDATA_RTP_MASK_MARKER)?1:0,
       pSp->pStream->hdr.key.ssrc, pSp->spFlags, pSp->pCapAction && pSp->pCapAction->pQueue ? 1 : 0);
    if(pPkt) {
      LOGHEX_DEBUG(pPkt->payload.pData, MIN(16, PKTCAPLEN(pPkt->payload)));
    }
  );
示例#4
0
int stream_udp(STREAM_XMIT_NODE_T *pList, double durationSec) {
  STREAM_XMIT_NODE_T *pStream;
  COLLECT_STREAM_PKTDATA_T collectPkt;
  int triedXmit;
  unsigned int idxDest;
  TIME_VAL tmstart, tm1, tmnow;
  TIME_VAL tmprevbwdescr;
  int rc;
  int sz;
  int szPkt;
  unsigned int szData;
  const unsigned char *pData;
  unsigned int szDataPayload;
  const unsigned char *pDataPayload;
  uint64_t totBytes = 0;
  unsigned int totPkts = 0;
  unsigned int bytes = 0;
  unsigned int pkts = 0;
  unsigned int bytes2 = 0;
  unsigned int pkts2 = 0;
  //char dstStr[64];
#ifndef WIN32
  unsigned int countIterations = 0;
#endif // WIN32

  if(!pList 
#if defined(VSX_HAVE_LICENSE)
   || !pList->pLic
#endif // VSX_HAVE_LICENSE
     ) {
    return -1;
  }

  //snprintf(dstStr, sizeof(dstStr), "%s:%d", inet_ntoa(pList->pRtpMulti->pdests[0].saDsts.sin_addr), 
  //            ntohs(pList->pRtpMulti->pdests[0].saDsts.sin_port));

  tmstart = tmnow = timer_GetTime();
  tm1 = tmstart;
  tmprevbwdescr = tmstart;


  while(*pList->prunning == STREAMER_STATE_RUNNING && !g_proc_exit) {

    pStream = pList;
    triedXmit = 0;

    while(pStream) {

      if((rc = pStream->cbCanSend(pStream->pCbData)) > 0) {

        pData = stream_rtp_data(pStream->pRtpMulti);
        szData = stream_rtp_datalen(pStream->pRtpMulti);

        if(szData >= RTP_HEADER_LEN) {
          pDataPayload = pData + RTP_HEADER_LEN;
          szDataPayload = szData - RTP_HEADER_LEN;
        } else {
          pDataPayload = NULL;
          szDataPayload = 0;
        }

        if(pStream->pXmitAction->do_stream) {
          triedXmit = 1;

          totPkts++;
          pkts++;
          pkts2++;

          if(pStream->pXmitAction->do_output) {

            szPkt = 0;
            for(idxDest = 0; idxDest < pStream->pRtpMulti->numDests; idxDest++) {
  
              if(pStream->pXmitDestRc[idxDest] != 0) {
                continue;
              }
              if(pStream->rawSend) {
                if(pktgen_Queue(pData, szData) != 0) {
                  pStream->pXmitDestRc[idxDest] = -1; 
                  sz = -1;
                } else {
                  sz = szData;
                }
              } else {

                //
                // Check and send an rtcp sender report
                //
                if(*pStream->pfrtcp_sr_intervalsec > 0 &&
                  (tmnow - pStream->pRtpMulti->pdests[idxDest].tmLastRtcpSr) / TIME_VAL_MS  > 
                         *pStream->pfrtcp_sr_intervalsec * 1000) {
                  sendRtcpSr(pStream, idxDest);
                  pStream->pRtpMulti->pdests[idxDest].tmLastRtcpSr = tmnow;
                } 

                if((sz = sendPktUdpRtp(pStream, idxDest, pData, szData)) < 0) {
                  pStream->pXmitDestRc[idxDest] = sz; 
                }
              }
              if(szPkt == 0 && sz > 0) {
                szPkt = sz; 
              }
            } // end of for

            // Exit if there are no good transmitters in the list
            if(pStream->pXmitAction->do_output && szPkt == 0) {
              return -1;
            }

          } else {    // if do_output
            szPkt = szData;
          }

          if(!pStream->pXmitAction->do_output_rtphdr && szPkt > RTP_HEADER_LEN) {
            szPkt -= RTP_HEADER_LEN;
          }

          totBytes += szPkt;
          bytes += szPkt;

          //
          // Add the packet data to any outbound avclive subscribers
          //
          // TODO: do not hardcode szData > RTP_HEADER_LEN rtp hdr len
          if(pStream->pLiveQ && pStream->pLiveQ->numActive > 0 && szDataPayload > 0) {
            pthread_mutex_lock(&pStream->pLiveQ->mtx);
            for(sz = 0; (unsigned int) sz < pStream->pLiveQ->max; sz++) {
              if(pStream->pLiveQ->pQs[sz]) {
                pktqueue_addpkt(pStream->pLiveQ->pQs[sz], pDataPayload, szDataPayload, NULL, 0);
              }
            }
            pthread_mutex_unlock(&pStream->pLiveQ->mtx);
          }
          bytes2 += szPkt;

        } else {

          // preserve rtp sequence number during 'live pause'
          //pStream->pRtp->m_pRtp->sequence_num = 
          //  htons(htons(pStream->pRtp->m_pRtp->sequence_num) - 1);

          //During 'live pause', update the last seq #
          //if(pStream->pXmitAction->prior_do_stream && pStream->prtp_sequence_at_end) {
          //  *pStream->prtp_sequence_at_end = pStream->pRtp->m_pRtp->sequence_num;
          //}
          //fprintf(stderr, "not streaming\n");

        }

        //
        // Record output stream
        //
        if(pStream->pXmitAction->do_record_post && pStream->pXmitCbs->cbRecord && 
           pStream->pXmitCbs->pCbRecordData) {

          memset(&collectPkt, 0, sizeof(collectPkt));
          collectPkt.payload.pData = (unsigned char *) pDataPayload;
          PKTCAPLEN(collectPkt.payload) = szDataPayload;
          if((sz = pStream->pXmitCbs->cbRecord(pStream->pXmitCbs->pCbRecordData, &collectPkt)) < 0) {
            return -1;
          }
          if(triedXmit == 0) {
            triedXmit = 1;
          }
        }

        //
        // Call post processing function, such as http live streaming
        // callback to segment and package output ts files 
        //
        if(pStream->pXmitAction->do_httplive && pStream->pXmitCbs->cbPostProc &&
           pStream->pXmitCbs->pCbPostProcData && pStream->pXmitAction->do_stream) {

          if((sz = pStream->pXmitCbs->cbPostProc(pStream->pXmitCbs->pCbPostProcData, 
                                                pDataPayload, szDataPayload)) < 0) {
            return -1;
          }
          if(triedXmit == 0) {
            triedXmit = 1;
          }
        }


        //if(pStream->pXmitAction->do_stream != pStream->pXmitAction->prior_do_stream) {
        //  pStream->pXmitAction->prior_do_stream = pStream->pXmitAction->do_stream;
        //}


        pStream->pRtpMulti->payloadLen = 0;

        if((rc = pStream->cbPreparePkt(pStream->pCbData)) < 0) {
          return -1;
        }
        //fprintf(stderr, "streamer prepare pkt returned %d\n", rc);

      } else if(rc < 0) {
        LOG(X_DEBUG("Stream ending, sent: %"LL64"u bytes %u pkts"), totBytes, totPkts); 
        return -1;
      } else {
        //fprintf(stderr, "streamer cansend rc:%d\n", rc);
      } 

      pStream = pStream->pNext;
    } // while(pStream)

    pktgen_SendQueued();


    if(triedXmit == 0) {

#ifdef WIN32

      //sl1 = timer_GetTime();

      //Sleep(1) may sleep past its short bedtime on win32, even from a thread w/ SCHED_RR
      //However, sleep(0) uses alot more cpu slices
      //TODO: make this a WaitForSingleObject for any registered pktqueue writers
      

      if(pList->pSleepQ) {
        //TODO: this does not return if a pkt has been queued and no subsequent pkt arrives
        pktqueue_waitforunreaddata(pList->pSleepQ);
        //pthread_cond_wait(pList->pCond, pList->pMtxCond);
      } else {
        Sleep(1);
      }

    } else {
      // On windows Sleep 0 relinquishes execution for any waiting threads
      Sleep(0);

#else // WIN32

      VSX_DEBUG2(tmnow = timer_GetTime())

      usleep(1000);
      countIterations = 0;

      VSX_DEBUGLOG3("stream_udp slept for %lld ns\n", timer_GetTime() - tmnow);

    } else {

      if(countIterations++ > 10000) {
        // During continuous xmit, sleep to prevent unresponsive system
        usleep(1);
        countIterations = 0;
      } 
#endif // WIN32

    } 

    tmnow = timer_GetTime();

    if(pList->pBwDescr && (tmnow / TIME_VAL_US) > (tmprevbwdescr / TIME_VAL_US) + 1) {
      pList->pBwDescr->intervalMs = (float)(tmnow - tmprevbwdescr)/ TIME_VAL_MS;
      pList->pBwDescr->pkts = pkts2;
      pList->pBwDescr->bytes = bytes2;
      TV_FROM_TIMEVAL(pList->pBwDescr->updateTv, tmnow);
      //pList->pBwDescr->updateTv.tv_sec = tmnow / TIME_VAL_US;
      //pList->pBwDescr->updateTv.tv_usec = tmnow % TIME_VAL_US;
      bytes2 = 0;
      pkts2 = 0;
      tmprevbwdescr = tmnow;
    }

    if(durationSec > 0 && tmnow > tmstart + (durationSec * TIME_VAL_US)) {
      LOG(X_DEBUG("Stream duration %.1f sec limit reached"), durationSec);
      *pList->prunning = STREAMER_STATE_FINISHED;
    }

#if defined (VSX_HAVE_LICENSE)
    // Check if stream time is limited
    if(!(pList->pLic->capabilities & LIC_CAP_STREAM_TIME_UNLIMITED)) {
      if(tmnow > tmstart + (STREAM_LIMIT_SEC * TIME_VAL_US)) {
        LOG(X_INFO("Stream time limited.  Stopping stream transmission after %d sec"), 
                 (int) (tmnow - tmstart) / TIME_VAL_US);
        *pList->prunning = STREAMER_STATE_FINISHED;
        if(!(g_proc_exit_flags & PROC_EXIT_FLAG_NO_EXIT_ON_STREAM_TIME_LIMITED)) {
          g_proc_exit = 1;
        }
      }
    }
#endif // VSX_HAVE_LICENSE

#if defined(LITE_VERSION)
    if(tmnow > tmstart + (STREAM_LIMIT_LITE_SEC * TIME_VAL_US)) {
      LOG(X_INFO("Stream time limited.  Stopping stream transmission after %d sec"),
               (int) (tmnow - tmstart) / TIME_VAL_US);
      *pList->prunning = STREAMER_STATE_FINISHED;
      if(!(g_proc_exit_flags & PROC_EXIT_FLAG_NO_EXIT_ON_STREAM_TIME_LIMITED)) {
        g_proc_exit = 1;
      }
    }
#endif // (LITE_VERSION)

/*
    if(0 && pList->verbosity > 1 && tv2.tv_sec > tv1.tv_sec+3) {

      elapsedMs0 = ((tv2.tv_sec - tv0.tv_sec) * 1000) + 
                   ((tv2.tv_usec - tv0.tv_usec) /1000);
      elapsedMs1 = ((tv2.tv_sec - tv1.tv_sec) * 1000) + 
                   ((tv2.tv_usec - tv1.tv_usec) /1000);

      fprintf(stdout, "%u", elapsedMs0/1000);
         
      if(durationSec != 0) {
        fprintf(stdout, "/%.1f", durationSec);
      }

      fprintf(stdout, " sec, %s %.1fKb/s %.1fpkts/s (total: %u pkts, %.1fKB, %.1fKb/s)",
           dstStr,
           (double)(bytes  / 128.0f / ((double)elapsedMs1/1000.0f)),
           (double)(pkts/ ((double)elapsedMs1/1000.0f)),
                         totPkts, (double)totBytes/1024.0f,
                           (double)(totBytes /  128.0f / ((double)elapsedMs0/1000.0f))); 
      fprintf(stdout, "\n");

      bytes = 0;
      pkts = 0;
      tv1.tv_sec = tv2.tv_sec;
      tv1.tv_usec = tv2.tv_usec;
    }
 */  
  }
示例#5
0
static int processPkt(CAPTURE_CBDATA_SP_T *pSp, const COLLECT_STREAM_PKTDATA_T *pPkt,
                        CAPTURE_STORE_CBDATA_T *pCbData) { 
  int rc = 0;
  const unsigned char *pData = pPkt->payload.pData;
  unsigned int len = PKTCAPLEN(pPkt->payload);
  unsigned int extHdrIdx = 0;
  unsigned int picId = 0;
  unsigned int partitionId;

  //fprintf(stderr, "pkt-len:%d ", len); avc_dumpHex(stderr, pPkt->payload.pData, MIN(16, PKTCAPLEN(pPkt->payload)), 0);

  //
  // http://www.potaroo.net/ietf/all-ids/draft-ietf-payload-vp8-08.txt
  //

  if(len < 1) {
    LOG(X_ERROR("RTP VP8 insufficient packet length %d, ssrc: 0x%x, seq:%u, ts:%u"), 
         len, pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts); 
    pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME);
    return -1;
  }

  if(pSp->lastPktTs != pPkt->u.rtp.ts) {
    memset(&pSp->u.vp8, 0, sizeof(pSp->u.vp8));
  }

  if((partitionId = (pData[0] & VP8_PARTITIONS_MASK)) >= VP8_PARTITIONS_COUNT) {
    LOG(X_ERROR("RTP VP8 invalid partition id %d, ssrc: 0x%x, seq:%u, ts:%u"), 
         partitionId, pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts); 
    return -1;
  }

  if((pSp->spFlags & CAPTURE_SP_FLAG_PREVLOST) && (pData[0] & VP8_PD_START_PARTITION) && partitionId > 0 && 
     pSp->u.vp8.partitions[partitionId - 1].byteIdx == 0) {

    LOG(X_ERROR("RTP VP8 start of partition[%d], but partition[%d] has %d bytes, %s, ssrc: 0x%x, seq:%u, ts:%u"), 
        partitionId, partitionId - 1, pSp->u.vp8.partitions[partitionId - 1].byteIdx, 
        (pSp->spFlags & CAPTURE_SP_FLAG_PREVLOST) ? " prior pkt lost" : "",
        pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts),
    pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME | CAPTURE_SP_FLAG_DROPFRAME);
    return -1;

  } else if((pData[0] & VP8_PD_START_PARTITION) && pSp->u.vp8.partitions[partitionId].byteIdx > 0) {

    LOG(X_ERROR("RTP VP8 partition bit set for continuation of partition[%d] byte[%d]%s, ssrc: 0x%x, seq:%u, ts:%u"), 
        partitionId, pSp->u.vp8.partitions[partitionId].byteIdx, 
        (pSp->spFlags & CAPTURE_SP_FLAG_PREVLOST) ? " prior pkt lost" : "",
        pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts),
    pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME | CAPTURE_SP_FLAG_DROPFRAME);
    return -1;

  } else if(!(pData[0] & VP8_PD_START_PARTITION) && pSp->pCapAction->tmpFrameBuf.idx == 0) {

    LOG(X_ERROR("RTP VP8 partition bit not set for presumed start of partition[%d] byte[%d]%s, ssrc: 0x%x, seq:%u, ts:%u"), 
        partitionId, pSp->u.vp8.partitions[partitionId].byteIdx,
        (pSp->spFlags & CAPTURE_SP_FLAG_PREVLOST) ? " prior pkt lost" : "",
        pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts),
    pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME | CAPTURE_SP_FLAG_DROPFRAME);
    return -1;

  }

  if(pData[0] & VP8_PD_RESERVED_BIT) {
    LOG(X_ERROR("RTP VP8 reserved bit should not be set, ssrc: 0x%x, seq:%u, ts:%u"), 
        pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts);
    pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME);
    return -1;
  }

  if(pData[0] & VP8_PD_EXTENDED_CTRL) {
    if(len < 2) {
      LOG(X_ERROR("RTP VP8 insufficient packet length %d, ssrc: 0x%x, seq:%u, ts:%u"), 
          len, pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts);
      pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME);
      return -1;
    }
    extHdrIdx++;
    if(pData[1] & VP8_PD_X_START_PICID_PRESENT) {
      extHdrIdx++;
      if(pData[2] & VP8_PD_I_START_PICID_16BIT) {
        extHdrIdx++;
        picId = htons(((pData[2] & 0x7f) << 8)| pData[3]);
      } else {
        picId = pData[2] & 0x7f;
      }
    }
    if(pData[1] & VP8_PD_X_START_TLOPICIDX_PRESENT) {
      extHdrIdx++;
    }
    if((pData[1] & VP8_PD_X_START_TID_PRESENT) || (pData[1] & VP8_PD_X_START_TID_KEYIDX_PRESENT)) {
      extHdrIdx++;
    }

  }
  extHdrIdx++;

  if(len < extHdrIdx) {
    LOG(X_ERROR("RTP VP8 insufficient packet length %d, ssrc: 0x%x, seq:%u, ts:%u"), 
        len, pSp->pStream->hdr.key.ssrc, pPkt->u.rtp.seq, pPkt->u.rtp.ts);
    return -1;
  }

  if(pSp->pCapAction->tmpFrameBuf.idx == 0 && (pData[0] & VP8_PD_START_PARTITION)) {
    if(VP8_ISKEYFRAME(&pData[extHdrIdx])) {
    //fprintf(stderr, "setting haveKeyFrame to 1 spFlags:0x%x\n\n", pSp->spFlags);
      pSp->spFlags |= CAPTURE_SP_FLAG_KEYFRAME;
      //LOG(X_DEBUG("cap-vp8 RTP pts:%.3f, seq:%u KEYFRAME"), (float) pPkt->u.rtp.ts / 90000, pPkt->u.rtp.seq); 
    } else {
      //LOG(X_DEBUG("cap-vp8 RTP pts:%.3f, seq:%u"), (float) pPkt->u.rtp.ts / 90000, pPkt->u.rtp.seq);
    }
  } 

  //TODO: handle RTP padding

  pSp->u.vp8.partitions[partitionId].byteIdx += (len - extHdrIdx);

  //LOG(X_DEBUG("vp8 storing data tmpFrame.buf.idx:%d, pktlen:%d,exthdridx:%d"), pSp->pCapAction->tmpFrameBuf.idx, len, extHdrIdx); LOGHEX_DEBUG(pData, MIN(16, PKTCAPLEN(pPkt->payload)));
  rc = pCbData->cbStoreData(pCbData->pCbDataArg, &pData[extHdrIdx], len - extHdrIdx);

  return rc;
}