| /* | |
| * RTP parser for VP9 payload format (draft version 02) - experimental | |
| * Copyright (c) 2015 Thomas Volkert <thomas@homer-conferencing.com> | |
| * | |
| * This file is part of FFmpeg. | |
| * | |
| * FFmpeg is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * FFmpeg is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with FFmpeg; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
| */ | |
| #include "libavutil/intreadwrite.h" | |
| #include "avio_internal.h" | |
| #include "rtpdec_formats.h" | |
| #define RTP_VP9_DESC_REQUIRED_SIZE 1 | |
| struct PayloadContext { | |
| AVIOContext *buf; | |
| uint32_t timestamp; | |
| }; | |
| static av_cold int vp9_init(AVFormatContext *ctx, int st_index, | |
| PayloadContext *data) | |
| { | |
| av_log(ctx, AV_LOG_WARNING, | |
| "RTP/VP9 support is still experimental\n"); | |
| return 0; | |
| } | |
| static int vp9_handle_packet(AVFormatContext *ctx, PayloadContext *rtp_vp9_ctx, | |
| AVStream *st, AVPacket *pkt, uint32_t *timestamp, | |
| const uint8_t *buf, int len, uint16_t seq, | |
| int flags) | |
| { | |
| int has_pic_id, has_layer_idc, has_ref_idc, has_ss_data; | |
| av_unused int pic_id = 0, non_key_frame = 0, inter_picture_layer_frame; | |
| av_unused int layer_temporal = -1, layer_spatial = -1, layer_quality = -1; | |
| int ref_fields = 0, has_ref_field_ext_pic_id = 0; | |
| int first_fragment, last_fragment; | |
| int rtp_m; | |
| int res = 0; | |
| /* drop data of previous packets in case of non-continuous (lossy) packet stream */ | |
| if (rtp_vp9_ctx->buf && rtp_vp9_ctx->timestamp != *timestamp) | |
| ffio_free_dyn_buf(&rtp_vp9_ctx->buf); | |
| /* sanity check for size of input packet: 1 byte payload at least */ | |
| if (len < RTP_VP9_DESC_REQUIRED_SIZE + 1) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet, got %d bytes\n", len); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| /* | |
| * decode the required VP9 payload descriptor according to section 4.2 of the spec.: | |
| * | |
| * 0 1 2 3 4 5 6 7 | |
| * +-+-+-+-+-+-+-+-+ | |
| * |I|P|L|F|B|E|V|-| (REQUIRED) | |
| * +-+-+-+-+-+-+-+-+ | |
| * | |
| * I: PictureID present | |
| * P: Inter-picture predicted layer frame | |
| * L: Layer indices present | |
| * F: Flexible mode | |
| * B: Start of VP9 frame | |
| * E: End of picture | |
| * V: Scalability Structure (SS) present | |
| */ | |
| has_pic_id = !!(buf[0] & 0x80); | |
| inter_picture_layer_frame = !!(buf[0] & 0x40); | |
| has_layer_idc = !!(buf[0] & 0x20); | |
| has_ref_idc = !!(buf[0] & 0x10); | |
| first_fragment = !!(buf[0] & 0x08); | |
| last_fragment = !!(buf[0] & 0x04); | |
| has_ss_data = !!(buf[0] & 0x02); | |
| rtp_m = !!(flags & RTP_FLAG_MARKER); | |
| /* sanity check for markers: B should always be equal to the RTP M marker */ | |
| if (last_fragment != rtp_m) { | |
| av_log(ctx, AV_LOG_ERROR, "Invalid combination of B and M marker (%d != %d)\n", last_fragment, rtp_m); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| /* pass the extensions field */ | |
| buf += RTP_VP9_DESC_REQUIRED_SIZE; | |
| len -= RTP_VP9_DESC_REQUIRED_SIZE; | |
| /* | |
| * decode the 1-byte/2-byte picture ID: | |
| * | |
| * 0 1 2 3 4 5 6 7 | |
| * +-+-+-+-+-+-+-+-+ | |
| * I: |M|PICTURE ID | (RECOMMENDED) | |
| * +-+-+-+-+-+-+-+-+ | |
| * M: | EXTENDED PID | (RECOMMENDED) | |
| * +-+-+-+-+-+-+-+-+ | |
| * | |
| * M: The most significant bit of the first octet is an extension flag. | |
| * PictureID: 8 or 16 bits including the M bit. | |
| */ | |
| if (has_pic_id) { | |
| /* check for 1-byte or 2-byte picture index */ | |
| if (buf[0] & 0x80) { | |
| if (len < 2) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| pic_id = AV_RB16(buf) & 0x7fff; | |
| buf += 2; | |
| len -= 2; | |
| } else { | |
| pic_id = buf[0] & 0x7f; | |
| buf++; | |
| len--; | |
| } | |
| } | |
| /* | |
| * decode layer indices | |
| * | |
| * 0 1 2 3 4 5 6 7 | |
| * +-+-+-+-+-+-+-+-+ | |
| * L: | T | S | Q | R | (CONDITIONALLY RECOMMENDED) | |
| * +-+-+-+-+-+-+-+-+ | |
| * | |
| * T, S and Q are 2-bit indices for temporal, spatial, and quality layers. | |
| * If "F" is set in the initial octet, R is 2 bits representing the number | |
| * of reference fields this frame refers to. | |
| */ | |
| if (has_layer_idc) { | |
| if (len < 1) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| layer_temporal = buf[0] & 0xC0; | |
| layer_spatial = buf[0] & 0x30; | |
| layer_quality = buf[0] & 0x0C; | |
| if (has_ref_idc) { | |
| ref_fields = buf[0] & 0x03; | |
| if (ref_fields) | |
| non_key_frame = 1; | |
| } | |
| buf++; | |
| len--; | |
| } | |
| /* | |
| * decode the reference fields | |
| * | |
| * 0 1 2 3 4 5 6 7 | |
| * +-+-+-+-+-+-+-+-+ -\ | |
| * F: | PID |X| RS| RQ| (OPTIONAL) . | |
| * +-+-+-+-+-+-+-+-+ . - R times | |
| * X: | EXTENDED PID | (OPTIONAL) . | |
| * +-+-+-+-+-+-+-+-+ -/ | |
| * | |
| * PID: The relative Picture ID referred to by this frame. | |
| * RS and RQ: The spatial and quality layer IDs. | |
| * X: 1 if this layer index has an extended relative Picture ID. | |
| */ | |
| if (has_ref_idc) { | |
| while (ref_fields) { | |
| if (len < 1) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| has_ref_field_ext_pic_id = buf[0] & 0x10; | |
| /* pass ref. field */ | |
| if (has_ref_field_ext_pic_id) { | |
| if (len < 2) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| /* ignore ref. data */ | |
| buf += 2; | |
| len -= 2; | |
| } else { | |
| /* ignore ref. data */ | |
| buf++; | |
| len--; | |
| } | |
| ref_fields--; | |
| } | |
| } | |
| /* | |
| * decode the scalability structure (SS) | |
| * | |
| * 0 1 2 3 4 5 6 7 | |
| * +-+-+-+-+-+-+-+-+ | |
| * V: | PATTERN LENGTH| | |
| * +-+-+-+-+-+-+-+-+ -\ | |
| * | T | S | Q | R | (OPTIONAL) . | |
| * +-+-+-+-+-+-+-+-+ -\ . | |
| * | PID |X| RS| RQ| (OPTIONAL) . . - PAT. LEN. times | |
| * +-+-+-+-+-+-+-+-+ . - R times . | |
| * X: | EXTENDED PID | (OPTIONAL) . . | |
| * +-+-+-+-+-+-+-+-+ -/ -/ | |
| * | |
| * PID: The relative Picture ID referred to by this frame. | |
| * RS and RQ: The spatial and quality layer IDs. | |
| * X: 1 if this layer index has an extended relative Picture ID. | |
| */ | |
| if (has_ss_data) { | |
| int n_s, y, g, i; | |
| if (len < 1) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| n_s = buf[0] >> 5; | |
| y = !!(buf[0] & 0x10); | |
| g = !!(buf[0] & 0x08); | |
| buf++; | |
| len--; | |
| if (n_s > 0) { | |
| avpriv_report_missing_feature(ctx, "VP9 scalability structure with multiple layers"); | |
| return AVERROR_PATCHWELCOME; | |
| } | |
| if (y) { | |
| if (len < 4 * (n_s + 1)) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| for (i = 0; i < n_s + 1; i++) { | |
| av_unused int w, h; | |
| w = AV_RB16(buf); | |
| h = AV_RB16(buf + 2); | |
| buf += 4; | |
| len -= 4; | |
| } | |
| } | |
| if (g) { | |
| int n_g; | |
| if (len < 1) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| n_g = buf[0]; | |
| buf++; | |
| len--; | |
| for (i = 0; i < n_g; i++) { | |
| av_unused int t, u, r, j; | |
| if (len < 1) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| t = buf[0] >> 5; | |
| u = !!(buf[0] & 0x10); | |
| r = (buf[0] >> 2) & 0x03; | |
| buf++; | |
| len--; | |
| if (len < r) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| for (j = 0; j < r; j++) { | |
| av_unused int p_diff = buf[0]; | |
| buf++; | |
| len--; | |
| } | |
| } | |
| } | |
| } | |
| /* | |
| * decode the VP9 payload header | |
| * | |
| * spec. is tbd | |
| */ | |
| //XXX: implement when specified | |
| /* sanity check: 1 byte payload as minimum */ | |
| if (len < 1) { | |
| av_log(ctx, AV_LOG_ERROR, "Too short RTP/VP9 packet\n"); | |
| return AVERROR_INVALIDDATA; | |
| } | |
| /* start frame buffering with new dynamic buffer */ | |
| if (!rtp_vp9_ctx->buf) { | |
| /* sanity check: a new frame should have started */ | |
| if (first_fragment) { | |
| res = avio_open_dyn_buf(&rtp_vp9_ctx->buf); | |
| if (res < 0) | |
| return res; | |
| /* update the timestamp in the frame packet with the one from the RTP packet */ | |
| rtp_vp9_ctx->timestamp = *timestamp; | |
| } else { | |
| /* frame not started yet, need more packets */ | |
| return AVERROR(EAGAIN); | |
| } | |
| } | |
| /* write the fragment to the dyn. buffer */ | |
| avio_write(rtp_vp9_ctx->buf, buf, len); | |
| /* do we need more fragments? */ | |
| if (!last_fragment) | |
| return AVERROR(EAGAIN); | |
| /* close frame buffering and create resulting A/V packet */ | |
| res = ff_rtp_finalize_packet(pkt, &rtp_vp9_ctx->buf, st->index); | |
| if (res < 0) | |
| return res; | |
| return 0; | |
| } | |
| static void vp9_close_context(PayloadContext *vp9) | |
| { | |
| ffio_free_dyn_buf(&vp9->buf); | |
| } | |
| const RTPDynamicProtocolHandler ff_vp9_dynamic_handler = { | |
| .enc_name = "VP9", | |
| .codec_type = AVMEDIA_TYPE_VIDEO, | |
| .codec_id = AV_CODEC_ID_VP9, | |
| .priv_data_size = sizeof(PayloadContext), | |
| .init = vp9_init, | |
| .close = vp9_close_context, | |
| .parse_packet = vp9_handle_packet | |
| }; |