diff options
Diffstat (limited to 'libavcodec/h264_mp4toannexb_bsf.c')
| -rw-r--r-- | libavcodec/h264_mp4toannexb_bsf.c | 164 |
1 files changed, 120 insertions, 44 deletions
diff --git a/libavcodec/h264_mp4toannexb_bsf.c b/libavcodec/h264_mp4toannexb_bsf.c index 3b212e5a55..e919360f96 100644 --- a/libavcodec/h264_mp4toannexb_bsf.c +++ b/libavcodec/h264_mp4toannexb_bsf.c @@ -2,20 +2,20 @@ * H.264 MP4 to Annex B byte stream format filter * Copyright (c) 2007 Benoit Fouet <benoit.fouet@free.fr> * - * This file is part of Libav. + * This file is part of FFmpeg. * - * Libav is free software; you can redistribute it and/or + * 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. * - * Libav is distributed in the hope that it will be useful, + * 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 Libav; if not, write to the Free Software + * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -26,9 +26,25 @@ #include "avcodec.h" typedef struct H264BSFContext { + int32_t sps_offset; + int32_t pps_offset; uint8_t length_size; - uint8_t first_idr; + uint8_t new_idr; + uint8_t idr_sps_seen; + uint8_t idr_pps_seen; int extradata_parsed; + + /* When private_spspps is zero then spspps_buf points to global extradata + and bsf does replace a global extradata to own-allocated version (default + behaviour). + When private_spspps is non-zero the bsf uses a private version of spspps buf. + This mode necessary when bsf uses in decoder, else bsf has issues after + decoder re-initialization. Use the "private_spspps_buf" argument to + activate this mode. + */ + int private_spspps; + uint8_t *spspps_buf; + uint32_t spspps_size; } H264BSFContext; static int alloc_and_copy(uint8_t **poutbuf, int *poutbuf_size, @@ -59,7 +75,7 @@ static int alloc_and_copy(uint8_t **poutbuf, int *poutbuf_size, return 0; } -static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding) +static int h264_extradata_to_annexb(H264BSFContext *ctx, AVCodecContext *avctx, const int padding) { uint16_t unit_size; uint64_t total_size = 0; @@ -69,18 +85,14 @@ static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding) static const uint8_t nalu_header[4] = { 0, 0, 0, 1 }; int length_size = (*extradata++ & 0x3) + 1; // retrieve length coded size - if (length_size == 3) - return AVERROR(EINVAL); + ctx->sps_offset = ctx->pps_offset = -1; /* retrieve sps and pps unit(s) */ unit_nb = *extradata++ & 0x1f; /* number of sps unit(s) */ if (!unit_nb) { - unit_nb = *extradata++; /* number of pps unit(s) */ - sps_done++; - - if (unit_nb) - pps_seen = 1; + goto pps; } else { + ctx->sps_offset = 0; sps_seen = 1; } @@ -89,9 +101,15 @@ static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding) unit_size = AV_RB16(extradata); total_size += unit_size + 4; - if (total_size > INT_MAX - padding || - extradata + 2 + unit_size > avctx->extradata + - avctx->extradata_size) { + if (total_size > INT_MAX - padding) { + av_log(avctx, AV_LOG_ERROR, + "Too big extradata size, corrupted stream or invalid MP4/AVCC bitstream\n"); + av_free(out); + return AVERROR(EINVAL); + } + if (extradata + 2 + unit_size > avctx->extradata + avctx->extradata_size) { + av_log(avctx, AV_LOG_ERROR, "Packet header is not contained in global extradata, " + "corrupted stream or invalid MP4/AVCC bitstream\n"); av_free(out); return AVERROR(EINVAL); } @@ -100,16 +118,18 @@ static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding) memcpy(out + total_size - unit_size - 4, nalu_header, 4); memcpy(out + total_size - unit_size, extradata + 2, unit_size); extradata += 2 + unit_size; - +pps: if (!unit_nb && !sps_done++) { unit_nb = *extradata++; /* number of pps unit(s) */ - if (unit_nb) + if (unit_nb) { + ctx->pps_offset = (extradata - 1) - (avctx->extradata + 4); pps_seen = 1; + } } } if (out) - memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); + memset(out + total_size, 0, padding); if (!sps_seen) av_log(avctx, AV_LOG_WARNING, @@ -121,9 +141,13 @@ static int h264_extradata_to_annexb(AVCodecContext *avctx, const int padding) "Warning: PPS NALU missing or invalid. " "The resulting stream may not play.\n"); - av_free(avctx->extradata); - avctx->extradata = out; - avctx->extradata_size = total_size; + if (!ctx->private_spspps) { + av_free(avctx->extradata); + avctx->extradata = out; + avctx->extradata_size = total_size; + } + ctx->spspps_buf = out; + ctx->spspps_size = total_size; return length_size; } @@ -135,6 +159,7 @@ static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, int keyframe) { H264BSFContext *ctx = bsfc->priv_data; + int i; uint8_t unit_type; int32_t nal_size; uint32_t cumul_size = 0; @@ -150,26 +175,28 @@ static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, /* retrieve sps and pps NAL units from extradata */ if (!ctx->extradata_parsed) { - ret = h264_extradata_to_annexb(avctx, FF_INPUT_BUFFER_PADDING_SIZE); + if (args && strstr(args, "private_spspps_buf")) + ctx->private_spspps = 1; + + ret = h264_extradata_to_annexb(ctx, avctx, FF_INPUT_BUFFER_PADDING_SIZE); if (ret < 0) return ret; ctx->length_size = ret; - ctx->first_idr = 1; + ctx->new_idr = 1; + ctx->idr_sps_seen = 0; + ctx->idr_pps_seen = 0; ctx->extradata_parsed = 1; } *poutbuf_size = 0; *poutbuf = NULL; do { + ret= AVERROR(EINVAL); if (buf + ctx->length_size > buf_end) goto fail; - if (ctx->length_size == 1) { - nal_size = buf[0]; - } else if (ctx->length_size == 2) { - nal_size = AV_RB16(buf); - } else - nal_size = AV_RB32(buf); + for (nal_size = 0, i = 0; i<ctx->length_size; i++) + nal_size = (nal_size << 8) | buf[i]; buf += ctx->length_size; unit_type = *buf & 0x1f; @@ -177,21 +204,62 @@ static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, if (buf + nal_size > buf_end || nal_size < 0) goto fail; - /* prepend only to the first type 5 NAL unit of an IDR picture */ - if (ctx->first_idr && unit_type == 5) { - if (alloc_and_copy(poutbuf, poutbuf_size, - avctx->extradata, avctx->extradata_size, - buf, nal_size) < 0) + if (unit_type == 7) + ctx->idr_sps_seen = ctx->new_idr = 1; + else if (unit_type == 8) { + ctx->idr_pps_seen = ctx->new_idr = 1; + /* if SPS has not been seen yet, prepend the AVCC one to PPS */ + if (!ctx->idr_sps_seen) { + if (ctx->sps_offset == -1) + av_log(avctx, AV_LOG_WARNING, "SPS not present in the stream, nor in AVCC, stream may be unreadable\n"); + else { + if ((ret = alloc_and_copy(poutbuf, poutbuf_size, + ctx->spspps_buf + ctx->sps_offset, + ctx->pps_offset != -1 ? ctx->pps_offset : ctx->spspps_size - ctx->sps_offset, + buf, nal_size)) < 0) + goto fail; + ctx->idr_sps_seen = 1; + goto next_nal; + } + } + } + + /* if this is a new IDR picture following an IDR picture, reset the idr flag. + * Just check first_mb_in_slice to be 0 as this is the simplest solution. + * This could be checking idr_pic_id instead, but would complexify the parsing. */ + if (!ctx->new_idr && unit_type == 5 && (buf[1] & 0x80)) + ctx->new_idr = 1; + + /* prepend only to the first type 5 NAL unit of an IDR picture, if no sps/pps are already present */ + if (ctx->new_idr && unit_type == 5 && !ctx->idr_sps_seen && !ctx->idr_pps_seen) { + if ((ret=alloc_and_copy(poutbuf, poutbuf_size, + ctx->spspps_buf, ctx->spspps_size, + buf, nal_size)) < 0) + goto fail; + ctx->new_idr = 0; + /* if only SPS has been seen, also insert PPS */ + } else if (ctx->new_idr && unit_type == 5 && ctx->idr_sps_seen && !ctx->idr_pps_seen) { + if (ctx->pps_offset == -1) { + av_log(avctx, AV_LOG_WARNING, "PPS not present in the stream, nor in AVCC, stream may be unreadable\n"); + if ((ret = alloc_and_copy(poutbuf, poutbuf_size, + NULL, 0, buf, nal_size)) < 0) + goto fail; + } else if ((ret = alloc_and_copy(poutbuf, poutbuf_size, + ctx->spspps_buf + ctx->pps_offset, ctx->spspps_size - ctx->pps_offset, + buf, nal_size)) < 0) goto fail; - ctx->first_idr = 0; } else { - if (alloc_and_copy(poutbuf, poutbuf_size, - NULL, 0, buf, nal_size) < 0) + if ((ret=alloc_and_copy(poutbuf, poutbuf_size, + NULL, 0, buf, nal_size)) < 0) goto fail; - if (!ctx->first_idr && unit_type == 1) - ctx->first_idr = 1; + if (!ctx->new_idr && unit_type == 1) { + ctx->new_idr = 1; + ctx->idr_sps_seen = 0; + ctx->idr_pps_seen = 0; + } } +next_nal: buf += nal_size; cumul_size += nal_size + ctx->length_size; } while (cumul_size < buf_size); @@ -201,11 +269,19 @@ static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc, fail: av_freep(poutbuf); *poutbuf_size = 0; - return AVERROR(EINVAL); + return ret; +} + +static void h264_mp4toannexb_filter_close(AVBitStreamFilterContext *bsfc) +{ + H264BSFContext *ctx = bsfc->priv_data; + if (ctx->private_spspps) + av_free(ctx->spspps_buf); } AVBitStreamFilter ff_h264_mp4toannexb_bsf = { - "h264_mp4toannexb", - sizeof(H264BSFContext), - h264_mp4toannexb_filter, + .name = "h264_mp4toannexb", + .priv_data_size = sizeof(H264BSFContext), + .filter = h264_mp4toannexb_filter, + .close = h264_mp4toannexb_filter_close, }; |