Merge commit 'f89f78c1c563d98f10ee1d7e1ed67c9f9e03b741'
authorMichael Niedermayer <michael@niedermayer.cc>
Sat, 25 Jul 2015 22:34:12 +0000 (00:34 +0200)
committerMichael Niedermayer <michael@niedermayer.cc>
Sat, 25 Jul 2015 22:34:27 +0000 (00:34 +0200)
* commit 'f89f78c1c563d98f10ee1d7e1ed67c9f9e03b741':
  lavc: add a HEVC mp4->annex B bitstream filter

Conflicts:
Changelog

Merged-by: Michael Niedermayer <michael@niedermayer.cc>
1  2 
Changelog
libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/hevc_mp4toannexb_bsf.c

diff --cc Changelog
+++ b/Changelog
@@@ -2,84 -2,17 +2,85 @@@ Entries are sorted chronologically fro
  releases are sorted from youngest to oldest.
  
  version <next>:
 -- aliases and defaults for Ogg subtypes (opus, spx)
 -- HEVC/H.265 RTP payload format (draft v6) packetizer and depacketizer
 -- avplay now exits by default at the end of playback
 -- XCB-based screen-grabber
 -- creating DASH compatible fragmented MP4, MPEG-DASH segmenting muxer
 -- H.261 RTP payload format (RFC 4587) depacketizer and experimental packetizer
 +- colorkey video filter
 +- BFSTM/BCSTM demuxer
 +- little-endian ADPCM_THP decoder
 +- Hap decoder and encoder
 +- DirectDraw Surface image/texture decoder
 +- ssim filter
 +- rewritten ASF demuxer
 +- showvolume filter
 +- Many improvements to the JPEG 2000 decoder
 +- Go2Meeting decoding support
 +- adrawgraph audio and drawgraph video filter
 +- removegrain video filter
 +- Intel QSV-accelerated MPEG-2 video and HEVC encoding
 +- Intel QSV-accelerated MPEG-2 video decoding
 +- Intel QSV-accelerated VC-1 video decoding
 +- libkvazaar HEVC encoder
 +- erosion, dilation, deflate and inflate video filters
 +- Dynamic Audio Normalizer as dynaudnorm filter
 +- Reverse video and areverse audio filter
 +- Random filter
 +- deband filter
 +- AAC fixed-point decoding
 +- sidechaincompress audio filter
++- bitstream filter for converting HEVC from MP4 to Annex B
 +
 +
 +version 2.7:
 +- FFT video filter
 +- TDSC decoder
 +- DTS lossless extension (XLL) decoding (not lossless, disabled by default)
 +- showwavespic filter
 +- DTS decoding through libdcadec
 +- Drop support for nvenc API before 5.0
 +- nvenc HEVC encoder
 +- Detelecine filter
 +- Intel QSV-accelerated H.264 encoding
 +- MMAL-accelerated H.264 decoding
 +- basic APNG encoder and muxer with default extension "apng"
 +- unpack DivX-style packed B-frames in MPEG-4 bitstream filter
 +- WebM Live Chunk Muxer
 +- nvenc level and tier options
 +- chorus filter
 +- Canopus HQ/HQA decoder
 +- Automatically rotate videos based on metadata in ffmpeg
 +- improved Quickdraw compatibility
 +- VP9 high bit-depth and extended colorspaces decoding support
 +- WebPAnimEncoder API when available for encoding and muxing WebP
 +- Direct3D11-accelerated decoding
 +- Support Secure Transport
 +- Multipart JPEG demuxer
 +
 +
 +version 2.6:
 +- nvenc encoder
 +- 10bit spp filter
 +- colorlevels filter
 +- RIFX format for *.wav files
  - RTP/mpegts muxer
 -- VP8 in Ogg demuxing
 +- non continuous cache protocol support
 +- tblend filter
 +- cropdetect support for non 8bpp, absolute (if limit >= 1) and relative (if limit < 1.0) threshold
 +- Camellia symmetric block cipher
  - OpenH264 encoder wrapper
 +- VOC seeking support
 +- Closed caption Decoder
 +- fspp, uspp, pp7 MPlayer postprocessing filters ported to native filters
 +- showpalette filter
 +- Twofish symmetric block cipher
  - Support DNx100 (960x720@8)
 -- Direct3D11-accelerated decoding
 +- eq2 filter ported from libmpcodecs as eq filter
 +- removed libmpcodecs
 +- Changed default DNxHD colour range in QuickTime .mov derivatives to mpeg range
 +- ported softpulldown filter from libmpcodecs as repeatfields filter
 +- dcshift filter
 +- RTP depacketizer for loss tolerant payload format for MP3 audio (RFC 5219)
 +- RTP depacketizer for AC3 payload format (RFC 4184)
 +- palettegen and paletteuse filters
 +- VP9 RTP payload format (draft 0) experimental depacketizer
 +- RTP depacketizer for DV (RFC 6469)
  - DXVA2-accelerated HEVC decoding
  - AAC ELD 480 decoding
  - Intel QSV-accelerated H.264 decoding
Simple merge
Simple merge
index 0000000,449c8a3..4263eae
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,186 +1,186 @@@
 - * This file is part of Libav.
+ /*
+  * HEVC MP4 to Annex B byte stream format filter
+  * copyright (c) 2015 Anton Khirnov
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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"
+ #include "bytestream.h"
+ #include "hevc.h"
+ #define MIN_HEVCC_LENGTH 23
+ typedef struct HEVCBSFContext {
+     uint8_t  length_size;
+     int      extradata_parsed;
+     int logged_nonmp4_warning;
+ } HEVCBSFContext;
+ static int hevc_extradata_to_annexb(AVCodecContext *avctx)
+ {
+     GetByteContext gb;
+     int length_size, num_arrays, i, j;
+     int ret = 0;
+     uint8_t *new_extradata = NULL;
+     size_t   new_extradata_size = 0;;
+     bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
+     bytestream2_skip(&gb, 21);
+     length_size = (bytestream2_get_byte(&gb) & 3) + 1;
+     num_arrays  = bytestream2_get_byte(&gb);
+     for (i = 0; i < num_arrays; i++) {
+         int type = bytestream2_get_byte(&gb) & 0x3f;
+         int cnt  = bytestream2_get_be16(&gb);
+         if (!(type == NAL_VPS || type == NAL_SPS || type == NAL_PPS ||
+               type == NAL_SEI_PREFIX || type == NAL_SEI_SUFFIX)) {
+             av_log(avctx, AV_LOG_ERROR, "Invalid NAL unit type in extradata: %d\n",
+                    type);
+             ret = AVERROR_INVALIDDATA;
+             goto fail;
+         }
+         for (j = 0; j < cnt; j++) {
+             int nalu_len = bytestream2_get_be16(&gb);
+             if (4 + FF_INPUT_BUFFER_PADDING_SIZE + nalu_len > SIZE_MAX - new_extradata_size) {
+                 ret = AVERROR_INVALIDDATA;
+                 goto fail;
+             }
+             ret = av_reallocp(&new_extradata, new_extradata_size + nalu_len + 4 + FF_INPUT_BUFFER_PADDING_SIZE);
+             if (ret < 0)
+                 goto fail;
+             AV_WB32(new_extradata + new_extradata_size, 1); // add the startcode
+             bytestream2_get_buffer(&gb, new_extradata + new_extradata_size + 4, nalu_len);
+             new_extradata_size += 4 + nalu_len;
+             memset(new_extradata + new_extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+         }
+     }
+     av_freep(&avctx->extradata);
+     avctx->extradata      = new_extradata;
+     avctx->extradata_size = new_extradata_size;
+     if (!new_extradata_size)
+         av_log(avctx, AV_LOG_WARNING, "No parameter sets in the extradata\n");
+     return length_size;
+ fail:
+     av_freep(&new_extradata);
+     return ret;
+ }
+ static int hevc_mp4toannexb_filter(AVBitStreamFilterContext *bsfc,
+                                    AVCodecContext *avctx, const char *args,
+                                    uint8_t **poutbuf, int *poutbuf_size,
+                                    const uint8_t *buf, int buf_size,
+                                    int keyframe)
+ {
+     HEVCBSFContext *ctx = bsfc->priv_data;
+     GetByteContext gb;
+     uint8_t *out = NULL;
+     size_t   out_size = 0;
+     int got_irap = 0;
+     int i, ret = 0;
+     if (!ctx->extradata_parsed) {
+         if (avctx->extradata_size < MIN_HEVCC_LENGTH ||
+             AV_RB24(avctx->extradata) == 1           ||
+             AV_RB32(avctx->extradata) == 1) {
+             if (!ctx->logged_nonmp4_warning) {
+                 av_log(avctx, AV_LOG_VERBOSE,
+                        "The input looks like it is Annex B already\n");
+                 ctx->logged_nonmp4_warning = 1;
+             }
+             *poutbuf      = buf;
+             *poutbuf_size = buf_size;
+             return 0;
+         }
+         ret = hevc_extradata_to_annexb(avctx);
+         if (ret < 0)
+             return ret;
+         ctx->length_size      = ret;
+         ctx->extradata_parsed = 1;
+     }
+     *poutbuf_size = 0;
+     *poutbuf      = NULL;
+     bytestream2_init(&gb, buf, buf_size);
+     while (bytestream2_get_bytes_left(&gb)) {
+         uint32_t nalu_size = 0;
+         int      nalu_type;
+         int is_irap, add_extradata, extra_size;
+         for (i = 0; i < ctx->length_size; i++)
+             nalu_size = (nalu_size << 8) | bytestream2_get_byte(&gb);
+         nalu_type = (bytestream2_peek_byte(&gb) >> 1) & 0x3f;
+         /* prepend extradata to IRAP frames */
+         is_irap       = nalu_type >= 16 && nalu_type <= 23;
+         add_extradata = is_irap && !got_irap;
+         extra_size    = add_extradata * avctx->extradata_size;
+         got_irap     |= is_irap;
+         if (SIZE_MAX - out_size < 4             ||
+             SIZE_MAX - out_size - 4 < nalu_size ||
+             SIZE_MAX - out_size - 4 - nalu_size < extra_size) {
+             ret = AVERROR_INVALIDDATA;
+             goto fail;
+         }
+         ret = av_reallocp(&out, out_size + 4 + nalu_size + extra_size);
+         if (ret < 0)
+             goto fail;
+         if (add_extradata)
+             memcpy(out + out_size, avctx->extradata, extra_size);
+         AV_WB32(out + out_size + extra_size, 1);
+         bytestream2_get_buffer(&gb, out + out_size + 4 + extra_size, nalu_size);
+         out_size += 4 + nalu_size + extra_size;
+     }
+     *poutbuf      = out;
+     *poutbuf_size = out_size;
+     return 1;
+ fail:
+     av_freep(&out);
+     return ret;
+ }
+ AVBitStreamFilter ff_hevc_mp4toannexb_bsf = {
+     "hevc_mp4toannexb",
+     sizeof(HEVCBSFContext),
+     hevc_mp4toannexb_filter,
+ };