[deb_ffmpeg.git] / ffmpeg / libavcodec / h264_mp4toannexb_bsf.c

/*
 * H.264 MP4 to Annex B byte stream format filter
 * Copyright (c) 2007 Benoit Fouet <benoit.fouet@free.fr>
 *
 * 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 <string.h>

#include "libavutil/intreadwrite.h"
#include "libavutil/mem.h"
#include "avcodec.h"

typedef struct H264BSFContext {
    int32_t  sps_offset;
    int32_t  pps_offset;
    uint8_t  length_size;
    uint8_t  new_idr;
    uint8_t  idr_sps_seen;
    uint8_t  idr_pps_seen;
    int      extradata_parsed;
} H264BSFContext;

static int alloc_and_copy(uint8_t **poutbuf, int *poutbuf_size,
                          const uint8_t *sps_pps, uint32_t sps_pps_size,
                          const uint8_t *in, uint32_t in_size)
{
    uint32_t offset         = *poutbuf_size;
    uint8_t nal_header_size = offset ? 3 : 4;
    int err;

    *poutbuf_size += sps_pps_size + in_size + nal_header_size;
    if ((err = av_reallocp(poutbuf,
                           *poutbuf_size + FF_INPUT_BUFFER_PADDING_SIZE)) < 0) {
        *poutbuf_size = 0;
        return err;
    }
    if (sps_pps)
        memcpy(*poutbuf + offset, sps_pps, sps_pps_size);
    memcpy(*poutbuf + sps_pps_size + nal_header_size + offset, in, in_size);
    if (!offset) {
        AV_WB32(*poutbuf + sps_pps_size, 1);
    } else {
        (*poutbuf + offset + sps_pps_size)[0] =
        (*poutbuf + offset + sps_pps_size)[1] = 0;
        (*poutbuf + offset + sps_pps_size)[2] = 1;
    }

    return 0;
}

static int h264_extradata_to_annexb(H264BSFContext *ctx, AVCodecContext *avctx, const int padding)
{
    uint16_t unit_size;
    uint64_t total_size                 = 0;
    uint8_t *out                        = NULL, unit_nb, sps_done = 0,
             sps_seen                   = 0, pps_seen = 0;
    const uint8_t *extradata            = avctx->extradata + 4;
    static const uint8_t nalu_header[4] = { 0, 0, 0, 1 };
    int length_size = (*extradata++ & 0x3) + 1; // retrieve length coded size

    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) {
        goto pps;
    } else {
        ctx->sps_offset = 0;
        sps_seen = 1;
    }

    while (unit_nb--) {
        int err;

        unit_size   = AV_RB16(extradata);
        total_size += unit_size + 4;
        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);
        }
        if ((err = av_reallocp(&out, total_size + padding)) < 0)
            return err;
        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) {
                ctx->pps_offset = (extradata - 1) - (avctx->extradata + 4);
                pps_seen = 1;
            }
        }
    }

    if (out)
        memset(out + total_size, 0, padding);

    if (!sps_seen)
        av_log(avctx, AV_LOG_WARNING,
               "Warning: SPS NALU missing or invalid. "
               "The resulting stream may not play.\n");

    if (!pps_seen)
        av_log(avctx, AV_LOG_WARNING,
               "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;

    return length_size;
}

static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc,
                                   AVCodecContext *avctx, const char *args,
                                   uint8_t **poutbuf, int *poutbuf_size,
                                   const uint8_t *buf, int buf_size,
                                   int keyframe)
{
    H264BSFContext *ctx = bsfc->priv_data;
    int i;
    uint8_t unit_type;
    int32_t nal_size;
    uint32_t cumul_size    = 0;
    const uint8_t *buf_end = buf + buf_size;
    int ret = 0;

    /* nothing to filter */
    if (!avctx->extradata || avctx->extradata_size < 6) {
        *poutbuf      = (uint8_t *)buf;
        *poutbuf_size = buf_size;
        return 0;
    }

    /* retrieve sps and pps NAL units from extradata */
    if (!ctx->extradata_parsed) {
        ret = h264_extradata_to_annexb(ctx, avctx, FF_INPUT_BUFFER_PADDING_SIZE);
        if (ret < 0)
            return ret;
        ctx->length_size      = ret;
        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;

        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;

        if (buf + nal_size > buf_end || nal_size < 0)
            goto fail;

        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,
                                         avctx->extradata + ctx->sps_offset,
                                         ctx->pps_offset != -1 ? ctx->pps_offset : avctx->extradata_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,
                               avctx->extradata, avctx->extradata_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,
                                        avctx->extradata + ctx->pps_offset, avctx->extradata_size - ctx->pps_offset,
                                        buf, nal_size)) < 0)
                goto fail;
        } else {
            if ((ret=alloc_and_copy(poutbuf, poutbuf_size,
                               NULL, 0, buf, nal_size)) < 0)
                goto fail;
            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);

    return 1;

fail:
    av_freep(poutbuf);
    *poutbuf_size = 0;
    return ret;
}

AVBitStreamFilter ff_h264_mp4toannexb_bsf = {
    .name           = "h264_mp4toannexb",
    .priv_data_size = sizeof(H264BSFContext),
    .filter         = h264_mp4toannexb_filter,
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* H.264 MP4 to Annex B byte stream format filter
	3	* Copyright (c) 2007 Benoit Fouet <benoit.fouet@free.fr>
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <string.h>
	23
	24	#include "libavutil/intreadwrite.h"
	25	#include "libavutil/mem.h"
	26	#include "avcodec.h"
	27
	28	typedef struct H264BSFContext {
f6fa7814 DM	29	int32_t sps_offset;
f6fa7814 DM	30	int32_t pps_offset;
2ba45a60 DM	31	uint8_t length_size;
2ba45a60 DM	32	uint8_t new_idr;
f6fa7814 DM	33	uint8_t idr_sps_seen;
f6fa7814 DM	34	uint8_t idr_pps_seen;
2ba45a60 DM	35	int extradata_parsed;
	36	} H264BSFContext;
	37
	38	static int alloc_and_copy(uint8_t *poutbuf, int poutbuf_size,
	39	const uint8_t *sps_pps, uint32_t sps_pps_size,
	40	const uint8_t *in, uint32_t in_size)
	41	{
	42	uint32_t offset = *poutbuf_size;
	43	uint8_t nal_header_size = offset ? 3 : 4;
	44	int err;
	45
	46	*poutbuf_size += sps_pps_size + in_size + nal_header_size;
	47	if ((err = av_reallocp(poutbuf,
	48	*poutbuf_size + FF_INPUT_BUFFER_PADDING_SIZE)) < 0) {
	49	*poutbuf_size = 0;
	50	return err;
	51	}
	52	if (sps_pps)
	53	memcpy(*poutbuf + offset, sps_pps, sps_pps_size);
	54	memcpy(*poutbuf + sps_pps_size + nal_header_size + offset, in, in_size);
	55	if (!offset) {
	56	AV_WB32(*poutbuf + sps_pps_size, 1);
	57	} else {
	58	(*poutbuf + offset + sps_pps_size)[0] =
	59	(*poutbuf + offset + sps_pps_size)[1] = 0;
	60	(*poutbuf + offset + sps_pps_size)[2] = 1;
	61	}
	62
	63	return 0;
	64	}
	65
f6fa7814	66	static int h264_extradata_to_annexb(H264BSFContext ctx, AVCodecContext avctx, const int padding)
2ba45a60 DM	67	{
	68	uint16_t unit_size;
	69	uint64_t total_size = 0;
	70	uint8_t *out = NULL, unit_nb, sps_done = 0,
	71	sps_seen = 0, pps_seen = 0;
	72	const uint8_t *extradata = avctx->extradata + 4;
	73	static const uint8_t nalu_header[4] = { 0, 0, 0, 1 };
	74	int length_size = (*extradata++ & 0x3) + 1; // retrieve length coded size
	75
f6fa7814 DM	76	ctx->sps_offset = ctx->pps_offset = -1;
f6fa7814 DM	77
2ba45a60 DM	78	/* retrieve sps and pps unit(s) */
	79	unit_nb = extradata++ & 0x1f; / number of sps unit(s) */
	80	if (!unit_nb) {
	81	goto pps;
	82	} else {
f6fa7814	83	ctx->sps_offset = 0;
2ba45a60 DM	84	sps_seen = 1;
	85	}
	86
	87	while (unit_nb--) {
	88	int err;
	89
	90	unit_size = AV_RB16(extradata);
	91	total_size += unit_size + 4;
	92	if (total_size > INT_MAX - padding) {
	93	av_log(avctx, AV_LOG_ERROR,
	94	"Too big extradata size, corrupted stream or invalid MP4/AVCC bitstream\n");
	95	av_free(out);
	96	return AVERROR(EINVAL);
	97	}
	98	if (extradata + 2 + unit_size > avctx->extradata + avctx->extradata_size) {
	99	av_log(avctx, AV_LOG_ERROR, "Packet header is not contained in global extradata, "
	100	"corrupted stream or invalid MP4/AVCC bitstream\n");
	101	av_free(out);
	102	return AVERROR(EINVAL);
	103	}
	104	if ((err = av_reallocp(&out, total_size + padding)) < 0)
	105	return err;
	106	memcpy(out + total_size - unit_size - 4, nalu_header, 4);
	107	memcpy(out + total_size - unit_size, extradata + 2, unit_size);
	108	extradata += 2 + unit_size;
	109	pps:
	110	if (!unit_nb && !sps_done++) {
	111	unit_nb = extradata++; / number of pps unit(s) */
f6fa7814 DM	112	if (unit_nb) {
f6fa7814 DM	113	ctx->pps_offset = (extradata - 1) - (avctx->extradata + 4);
2ba45a60	114	pps_seen = 1;
f6fa7814	115	}
2ba45a60 DM	116	}
	117	}
	118
	119	if (out)
f6fa7814	120	memset(out + total_size, 0, padding);
2ba45a60 DM	121
	122	if (!sps_seen)
	123	av_log(avctx, AV_LOG_WARNING,
	124	"Warning: SPS NALU missing or invalid. "
	125	"The resulting stream may not play.\n");
	126
	127	if (!pps_seen)
	128	av_log(avctx, AV_LOG_WARNING,
	129	"Warning: PPS NALU missing or invalid. "
	130	"The resulting stream may not play.\n");
	131
	132	av_free(avctx->extradata);
	133	avctx->extradata = out;
	134	avctx->extradata_size = total_size;
	135
	136	return length_size;
	137	}
	138
	139	static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc,
	140	AVCodecContext avctx, const char args,
	141	uint8_t *poutbuf, int poutbuf_size,
	142	const uint8_t *buf, int buf_size,
	143	int keyframe)
	144	{
	145	H264BSFContext *ctx = bsfc->priv_data;
	146	int i;
	147	uint8_t unit_type;
	148	int32_t nal_size;
	149	uint32_t cumul_size = 0;
	150	const uint8_t *buf_end = buf + buf_size;
	151	int ret = 0;
	152
	153	/* nothing to filter */
	154	if (!avctx->extradata \|\| avctx->extradata_size < 6) {
	155	poutbuf = (uint8_t )buf;
	156	*poutbuf_size = buf_size;
	157	return 0;
	158	}
	159
	160	/* retrieve sps and pps NAL units from extradata */
	161	if (!ctx->extradata_parsed) {
f6fa7814	162	ret = h264_extradata_to_annexb(ctx, avctx, FF_INPUT_BUFFER_PADDING_SIZE);
2ba45a60 DM	163	if (ret < 0)
	164	return ret;
	165	ctx->length_size = ret;
	166	ctx->new_idr = 1;
f6fa7814 DM	167	ctx->idr_sps_seen = 0;
f6fa7814 DM	168	ctx->idr_pps_seen = 0;
2ba45a60 DM	169	ctx->extradata_parsed = 1;
	170	}
	171
	172	*poutbuf_size = 0;
	173	*poutbuf = NULL;
	174	do {
	175	ret= AVERROR(EINVAL);
	176	if (buf + ctx->length_size > buf_end)
	177	goto fail;
	178
	179	for (nal_size = 0, i = 0; i<ctx->length_size; i++)
	180	nal_size = (nal_size << 8) \| buf[i];
	181
	182	buf += ctx->length_size;
	183	unit_type = *buf & 0x1f;
	184
	185	if (buf + nal_size > buf_end \|\| nal_size < 0)
	186	goto fail;
	187
f6fa7814 DM	188	if (unit_type == 7)
	189	ctx->idr_sps_seen = ctx->new_idr = 1;
	190	else if (unit_type == 8) {
	191	ctx->idr_pps_seen = ctx->new_idr = 1;
	192	/* if SPS has not been seen yet, prepend the AVCC one to PPS */
	193	if (!ctx->idr_sps_seen) {
	194	if (ctx->sps_offset == -1)
	195	av_log(avctx, AV_LOG_WARNING, "SPS not present in the stream, nor in AVCC, stream may be unreadable\n");
	196	else {
	197	if ((ret = alloc_and_copy(poutbuf, poutbuf_size,
	198	avctx->extradata + ctx->sps_offset,
	199	ctx->pps_offset != -1 ? ctx->pps_offset : avctx->extradata_size - ctx->sps_offset,
	200	buf, nal_size)) < 0)
	201	goto fail;
	202	ctx->idr_sps_seen = 1;
	203	goto next_nal;
	204	}
	205	}
	206	}
2ba45a60 DM	207
	208	/* if this is a new IDR picture following an IDR picture, reset the idr flag.
	209	* Just check first_mb_in_slice to be 0 as this is the simplest solution.
	210	* This could be checking idr_pic_id instead, but would complexify the parsing. */
	211	if (!ctx->new_idr && unit_type == 5 && (buf[1] & 0x80))
	212	ctx->new_idr = 1;
	213
	214	/* prepend only to the first type 5 NAL unit of an IDR picture, if no sps/pps are already present */
f6fa7814	215	if (ctx->new_idr && unit_type == 5 && !ctx->idr_sps_seen && !ctx->idr_pps_seen) {
2ba45a60 DM	216	if ((ret=alloc_and_copy(poutbuf, poutbuf_size,
	217	avctx->extradata, avctx->extradata_size,
	218	buf, nal_size)) < 0)
	219	goto fail;
	220	ctx->new_idr = 0;
f6fa7814 DM	221	/* if only SPS has been seen, also insert PPS */
	222	} else if (ctx->new_idr && unit_type == 5 && ctx->idr_sps_seen && !ctx->idr_pps_seen) {
	223	if (ctx->pps_offset == -1) {
	224	av_log(avctx, AV_LOG_WARNING, "PPS not present in the stream, nor in AVCC, stream may be unreadable\n");
	225	if ((ret = alloc_and_copy(poutbuf, poutbuf_size,
	226	NULL, 0, buf, nal_size)) < 0)
	227	goto fail;
	228	} else if ((ret = alloc_and_copy(poutbuf, poutbuf_size,
	229	avctx->extradata + ctx->pps_offset, avctx->extradata_size - ctx->pps_offset,
	230	buf, nal_size)) < 0)
	231	goto fail;
2ba45a60 DM	232	} else {
	233	if ((ret=alloc_and_copy(poutbuf, poutbuf_size,
	234	NULL, 0, buf, nal_size)) < 0)
	235	goto fail;
	236	if (!ctx->new_idr && unit_type == 1) {
	237	ctx->new_idr = 1;
f6fa7814 DM	238	ctx->idr_sps_seen = 0;
f6fa7814 DM	239	ctx->idr_pps_seen = 0;
2ba45a60 DM	240	}
	241	}
	242
f6fa7814	243	next_nal:
2ba45a60 DM	244	buf += nal_size;
	245	cumul_size += nal_size + ctx->length_size;
	246	} while (cumul_size < buf_size);
	247
	248	return 1;
	249
	250	fail:
	251	av_freep(poutbuf);
	252	*poutbuf_size = 0;
	253	return ret;
	254	}
	255
	256	AVBitStreamFilter ff_h264_mp4toannexb_bsf = {
	257	.name = "h264_mp4toannexb",
	258	.priv_data_size = sizeof(H264BSFContext),
	259	.filter = h264_mp4toannexb_filter,
	260	};