static int rtp_parse_one_packet(RTPDemuxContext *s, AVPacket *pkt, uint8_t **bufptr, int len) { uint8_t* buf = bufptr ? *bufptr : NULL; int ret, flags = 0; uint32_t timestamp; int rv= 0; if (!buf) { /* If parsing of the previous packet actually returned 0 or an error, * there's nothing more to be parsed from that packet, but we may have * indicated that we can return the next enqueued packet. */ if (s->prev_ret <= 0) return rtp_parse_queued_packet(s, pkt); /* return the next packets, if any */ if(s->st && s->parse_packet) { /* timestamp should be overwritten by parse_packet, if not, * the packet is left with pts == AV_NOPTS_VALUE */ timestamp = RTP_NOTS_VALUE; rv= s->parse_packet(s->ic, s->dynamic_protocol_context, s->st, pkt, ×tamp, NULL, 0, flags); finalize_packet(s, pkt, timestamp); return rv; } else { // TODO: Move to a dynamic packet handler (like above) if (s->read_buf_index >= s->read_buf_size) return AVERROR(EAGAIN); ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index, s->read_buf_size - s->read_buf_index); if (ret < 0) return AVERROR(EAGAIN); s->read_buf_index += ret; if (s->read_buf_index < s->read_buf_size) return 1; else return 0; } } if (len < 12) return -1; if ((buf[0] & 0xc0) != (RTP_VERSION << 6)) return -1; if (buf[1] >= RTCP_SR && buf[1] <= RTCP_APP) { return rtcp_parse_packet(s, buf, len); } if ((s->seq == 0 && !s->queue) || s->queue_size <= 1) { /* First packet, or no reordering */ return rtp_parse_packet_internal(s, pkt, buf, len); } else { uint16_t seq = AV_RB16(buf + 2); int16_t diff = seq - s->seq; if (diff < 0) { /* Packet older than the previously emitted one, drop */ av_log(s->st ? s->st->codec : NULL, AV_LOG_WARNING, "RTP: dropping old packet received too late\n"); return -1; } else if (diff <= 1) { /* Correct packet */ rv = rtp_parse_packet_internal(s, pkt, buf, len); return rv; } else { /* Still missing some packet, enqueue this one. */ enqueue_packet(s, buf, len); *bufptr = NULL; /* Return the first enqueued packet if the queue is full, * even if we're missing something */ if (s->queue_len >= s->queue_size) return rtp_parse_queued_packet(s, pkt); return -1; } } }
/** * Parse an RTP or RTCP packet directly sent as a buffer. * @param s RTP parse context. * @param pkt returned packet * @param buf input buffer or NULL to read the next packets * @param len buffer len * @return 0 if a packet is returned, 1 if a packet is returned and more can follow * (use buf as NULL to read the next). -1 if no packet (error or no more packet). */ int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, const uint8_t *buf, int len) { unsigned int ssrc, h; int payload_type, seq, ret, flags = 0; AVStream *st; uint32_t timestamp; int rv= 0; if (!buf) { /* return the next packets, if any */ if(s->st && s->parse_packet) { /* timestamp should be overwritten by parse_packet, if not, * the packet is left with pts == AV_NOPTS_VALUE */ timestamp = RTP_NOTS_VALUE; rv= s->parse_packet(s->ic, s->dynamic_protocol_context, s->st, pkt, ×tamp, NULL, 0, flags); finalize_packet(s, pkt, timestamp); return rv; } else { // TODO: Move to a dynamic packet handler (like above) if (s->read_buf_index >= s->read_buf_size) return -1; ret = ff_mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index, s->read_buf_size - s->read_buf_index); if (ret < 0) return -1; s->read_buf_index += ret; if (s->read_buf_index < s->read_buf_size) return 1; else return 0; } } if (len < 12) return -1; if ((buf[0] & 0xc0) != (RTP_VERSION << 6)) return -1; if (buf[1] >= 200 && buf[1] <= 204) { rtcp_parse_packet(s, buf, len); return -1; } payload_type = buf[1] & 0x7f; if (buf[1] & 0x80) flags |= RTP_FLAG_MARKER; seq = AV_RB16(buf + 2); timestamp = AV_RB32(buf + 4); ssrc = AV_RB32(buf + 8); /* store the ssrc in the RTPDemuxContext */ s->ssrc = ssrc; /* NOTE: we can handle only one payload type */ if (s->payload_type != payload_type) return -1; st = s->st; // only do something with this if all the rtp checks pass... if(!rtp_valid_packet_in_sequence(&s->statistics, seq)) { av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n", payload_type, seq, ((s->seq + 1) & 0xffff)); return -1; } s->seq = seq; len -= 12; buf += 12; if (!st) { /* specific MPEG2TS demux support */ ret = ff_mpegts_parse_packet(s->ts, pkt, buf, len); if (ret < 0) return -1; if (ret < len) { s->read_buf_size = len - ret; memcpy(s->buf, buf + ret, s->read_buf_size); s->read_buf_index = 0; return 1; } return 0; } else if (s->parse_packet) { rv = s->parse_packet(s->ic, s->dynamic_protocol_context, s->st, pkt, ×tamp, buf, len, flags); } else { // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise. switch(st->codec->codec_id) { case CODEC_ID_MP2: case CODEC_ID_MP3: /* better than nothing: skip mpeg audio RTP header */ if (len <= 4) return -1; h = AV_RB32(buf); len -= 4; buf += 4; av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; case CODEC_ID_MPEG1VIDEO: case CODEC_ID_MPEG2VIDEO: /* better than nothing: skip mpeg video RTP header */ if (len <= 4) return -1; h = AV_RB32(buf); buf += 4; len -= 4; if (h & (1 << 26)) { /* mpeg2 */ if (len <= 4) return -1; buf += 4; len -= 4; } av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; default: av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; } pkt->stream_index = st->index; } // now perform timestamp things.... finalize_packet(s, pkt, timestamp); return rv; }
/** * Parse an RTP or RTCP packet directly sent as a buffer. * @param s RTP parse context. * @param pkt returned packet * @param buf input buffer or NULL to read the next packets * @param len buffer len * @return 0 if a packet is returned, 1 if a packet is returned and more can follow * (use buf as NULL to read the next). -1 if no packet (error or no more packet). */ int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, const uint8_t *buf, int len) { unsigned int ssrc, h; int payload_type, seq, ret, flags = 0; AVStream *st; uint32_t timestamp; int rv= 0; if (!buf) { /* return the next packets, if any */ if(s->st && s->parse_packet) { timestamp= 0; ///< Should not be used if buf is NULL, but should be set to the timestamp of the packet returned.... rv= s->parse_packet(s, pkt, ×tamp, NULL, 0, flags); finalize_packet(s, pkt, timestamp); return rv; } else { // TODO: Move to a dynamic packet handler (like above) if (s->read_buf_index >= s->read_buf_size) return -1; ret = mpegts_parse_packet(s->ts, pkt, s->buf + s->read_buf_index, s->read_buf_size - s->read_buf_index); if (ret < 0) return -1; s->read_buf_index += ret; if (s->read_buf_index < s->read_buf_size) return 1; else return 0; } } if (len < 12) return -1; if ((buf[0] & 0xc0) != (RTP_VERSION << 6)) return -1; if (buf[1] >= 200 && buf[1] <= 204) { rtcp_parse_packet(s, buf, len); return -1; } payload_type = buf[1] & 0x7f; seq = AV_RB16(buf + 2); timestamp = AV_RB32(buf + 4); ssrc = AV_RB32(buf + 8); /* store the ssrc in the RTPDemuxContext */ s->ssrc = ssrc; /* NOTE: we can handle only one payload type */ if (s->payload_type != payload_type) return -1; st = s->st; // only do something with this if all the rtp checks pass... if(!rtp_valid_packet_in_sequence(&s->statistics, seq)) { av_log(st?st->codec:NULL, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n", payload_type, seq, ((s->seq + 1) & 0xffff)); return -1; } s->seq = seq; len -= 12; buf += 12; if (!st) { /* specific MPEG2TS demux support */ ret = mpegts_parse_packet(s->ts, pkt, buf, len); if (ret < 0) return -1; if (ret < len) { s->read_buf_size = len - ret; memcpy(s->buf, buf + ret, s->read_buf_size); s->read_buf_index = 0; return 1; } } else if (s->parse_packet) { rv = s->parse_packet(s, pkt, ×tamp, buf, len, flags); } else { // at this point, the RTP header has been stripped; This is ASSUMING that there is only 1 CSRC, which in't wise. switch(st->codec->codec_id) { case CODEC_ID_MP2: /* better than nothing: skip mpeg audio RTP header */ if (len <= 4) return -1; h = AV_RB32(buf); len -= 4; buf += 4; av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; case CODEC_ID_MPEG1VIDEO: case CODEC_ID_MPEG2VIDEO: /* better than nothing: skip mpeg video RTP header */ if (len <= 4) return -1; h = AV_RB32(buf); buf += 4; len -= 4; if (h & (1 << 26)) { /* mpeg2 */ if (len <= 4) return -1; buf += 4; len -= 4; } av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; // moved from below, verbatim. this is because this section handles packets, and the lower switch handles // timestamps. // TODO: Put this into a dynamic packet handler... case CODEC_ID_AAC: if (rtp_parse_mp4_au(s, buf)) return -1; { rtp_payload_data_t *infos = s->rtp_payload_data; if (infos == NULL) return -1; buf += infos->au_headers_length_bytes + 2; len -= infos->au_headers_length_bytes + 2; /* XXX: Fixme we only handle the case where rtp_parse_mp4_au define one au_header */ av_new_packet(pkt, infos->au_headers[0].size); memcpy(pkt->data, buf, infos->au_headers[0].size); buf += infos->au_headers[0].size; len -= infos->au_headers[0].size; } s->read_buf_size = len; rv= 0; break; default: av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; } // now perform timestamp things.... finalize_packet(s, pkt, timestamp); } return rv; }
/** * Parse an RTP packet directly sent as raw data. Can only be used if * 'raw' is given as input file * @param s1 media file context * @param pkt returned packet * @param buf input buffer * @param len buffer len * @return zero if no error. */ int rtp_parse_packet(AVFormatContext *s1, AVPacket *pkt, const unsigned char *buf, int len) { RTPContext *s = s1->priv_data; unsigned int ssrc, h; int payload_type, seq, delta_timestamp,idx; AVStream *st; uint32_t timestamp; if (len < 12) return -1; if ((buf[0] & 0xc0) != (RTP_VERSION << 6)) return -1; if (buf[1] >= 200 && buf[1] <= 204) { rtcp_parse_packet(s1, buf, len); if(pkt&&(pkt->data!=0)) { //printf("free_packet\n");fflush(stdout); av_free_packet(pkt); } if(s->profile.a_size>0) s->seq=s->profile.a_seq-1; else if(s->profile.v_size>0) s->seq=s->profile.v_seq-1; else return -1; s->a_offset=0; s->v_offset=0; switch_order=1; s->first_rtcp=1; //need the first video rtcp packet for re-sync return -1; } payload_type = buf[1] & 0x7f; seq = (buf[2] << 8) | buf[3]; timestamp = decode_be32(buf + 4); ssrc = decode_be32(buf + 8); #ifdef DEBUG //1 printf("payload_type %d, seq=%d timestamp=0x%x first_rtcp=%d\n",payload_type,seq,timestamp,s->first_rtcp); fflush(stdout); #endif if(s->first_rtcp==0) { //printf("NO first rtcp comming!\n"); switch_order=0; return -1; } #if 1 //ivan if(s->payload_record[0]<0) s->payload_record[0] = payload_type; else if(s->payload_record[1]<0) s->payload_record[1] = payload_type; if((payload_type==RTP_PT_MPEG4VIDEO)||(payload_type==RTP_PT_MJPEG)||(payload_type==RTP_PT_H264)) idx=0; else if(payload_type==RTP_PT_ADPCM) idx=1; else return -1; #else if (s->payload_type < 0) { s->payload_type = payload_type; if (payload_type == RTP_PT_MPEG2TS) { /* XXX: special case : not a single codec but a whole stream */ return -1; } else { st = av_new_stream(s1, 0); if (!st) return -1; rtp_get_codec_info(&st->codec, payload_type); } } /* NOTE: we can handle only one payload type */ if (s->payload_type != payload_type) return -1; #endif #if defined(DEBUG) || 1 if(seq != 0) //ivan if (seq != ((s->seq + 1) & 0xffff)) { printf("RTP: PT=%02x: bad cseq %04x expected=%04x\n", payload_type, seq, ((s->seq + 1) & 0xffff)); s->seq = seq; if(pkt&&(pkt->data!=0)) { //printf("free_packet\n");fflush(stdout); av_free_packet(pkt); } switch_order=0; s->first_rtcp=0; return -1; } s->seq = seq; #else s->seq = seq; #endif len -= 12; buf += 12; st = s1->streams[idx]; switch(st->codec.codec_id) { case CODEC_ID_MP2: /* better than nothing: skip mpeg audio RTP header */ if (len <= 4) return -1; h = decode_be32(buf); len -= 4; buf += 4; av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; case CODEC_ID_MPEG1VIDEO: /* better than nothing: skip mpeg audio RTP header */ if (len <= 4) return -1; h = decode_be32(buf); buf += 4; len -= 4; if (h & (1 << 26)) { /* mpeg2 */ if (len <= 4) return -1; buf += 4; len -= 4; } av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; case CODEC_ID_MPEG4: case CODEC_ID_MJPEG: case CODEC_ID_H264: if(pkt&&(pkt->data!=0)&&(s->a_offset!=0)) av_free_packet(pkt); if(pkt->data==0) { if(av_new_packet(pkt,s->profile.v_size)<0) return -1; pkt->stream_index=0; } if((s->v_offset+len)>s->profile.v_size) { //printf("Packet Alignment Fail! free it!\n");fflush(stdout); av_free_packet(pkt); return -1; } memcpy(pkt->data+s->v_offset, buf, len); s->v_offset+=len; break; case CODEC_ID_ADPCM_IMA_WAV: if(pkt&&(pkt->data!=0)&&(s->v_offset!=0)) av_free_packet(pkt); if(pkt->data==0) { if(av_new_packet(pkt,s->profile.a_size)<0) return -1; pkt->stream_index=1; } if((s->a_offset+len)>s->profile.a_size) { //printf("Packet Alignment Fail! free it!\n");fflush(stdout); av_free_packet(pkt); return -1; } memcpy(pkt->data+s->a_offset, buf, len); s->a_offset+=len; break; default: av_new_packet(pkt, len); memcpy(pkt->data, buf, len); break; } switch(st->codec.codec_id) { case CODEC_ID_MP2: case CODEC_ID_MPEG1VIDEO: case CODEC_ID_ADPCM_IMA_WAV: case CODEC_ID_MPEG4: case CODEC_ID_MJPEG: case CODEC_ID_H264: if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) { int64_t addend; /* XXX: is it really necessary to unify the timestamp base ? */ /* compute pts from timestamp with received ntp_time */ delta_timestamp = timestamp - s->last_rtcp_timestamp; /* convert to 90 kHz without overflow */ addend = (s->last_rtcp_ntp_time - s->first_rtcp_ntp_time) >> 14; addend = (addend * 5625) >> 14; pkt->pts = addend + delta_timestamp; } break; default: /* no timestamp info yet */ break; }