Merge commit '7ca3e5203f133eb41a0b5c3a1d753a7427ba72e7'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 22 Jun 2015 20:33:46 +0000 (22:33 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 22 Jun 2015 20:47:32 +0000 (22:47 +0200)
* commit '7ca3e5203f133eb41a0b5c3a1d753a7427ba72e7':
  Hap decoder and encoder

Conflicts:
Changelog
configure
doc/general.texi
libavcodec/allcodecs.c
libavcodec/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
16 files changed:
1  2 
Changelog
configure
doc/general.texi
libavcodec/Makefile
libavcodec/allcodecs.c
libavcodec/avcodec.h
libavcodec/codec_desc.c
libavcodec/hap.h
libavcodec/hapdec.c
libavcodec/hapenc.c
libavcodec/version.h
libavformat/isom.c
tests/fate/video.mak
tests/ref/fate/hap1
tests/ref/fate/hap5
tests/ref/fate/hapy

diff --cc Changelog
+++ b/Changelog
@@@ -2,64 -2,17 +2,65 @@@ 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
 +
 +
 +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
++- Hap decoder and encoder
 +
 +
 +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
diff --cc configure
+++ b/configure
@@@ -234,24 -200,15 +234,25 @@@ External library support
    --enable-libopenjpeg     enable JPEG 2000 de/encoding via OpenJPEG [no]
    --enable-libopus         enable Opus de/encoding via libopus [no]
    --enable-libpulse        enable Pulseaudio input via libpulse [no]
 +  --enable-libquvi         enable quvi input via libquvi [no]
    --enable-librtmp         enable RTMP[E] support via librtmp [no]
    --enable-libschroedinger enable Dirac de/encoding via libschroedinger [no]
 +  --enable-libshine        enable fixed-point MP3 encoding via libshine [no]
 +  --enable-libsmbclient    enable Samba protocol via libsmbclient [no]
+   --enable-libsnappy       enable Snappy compression [no]
 +  --enable-libsoxr         enable Include libsoxr resampling [no]
    --enable-libspeex        enable Speex de/encoding via libspeex [no]
 +  --enable-libssh          enable SFTP protocol via libssh [no]
 +  --enable-libstagefright-h264  enable H.264 decoding via libstagefright [no]
    --enable-libtheora       enable Theora encoding via libtheora [no]
    --enable-libtwolame      enable MP2 encoding via libtwolame [no]
 +  --enable-libutvideo      enable Ut Video encoding and decoding via libutvideo [no]
 +  --enable-libv4l2         enable libv4l2/v4l-utils [no]
 +  --enable-libvidstab      enable video stabilization using vid.stab [no]
    --enable-libvo-aacenc    enable AAC encoding via libvo-aacenc [no]
    --enable-libvo-amrwbenc  enable AMR-WB encoding via libvo-amrwbenc [no]
 -  --enable-libvorbis       enable Vorbis encoding via libvorbis [no]
 +  --enable-libvorbis       enable Vorbis en/decoding via libvorbis,
 +                           native implementation exists [no]
    --enable-libvpx          enable VP8 and VP9 de/encoding via libvpx [no]
    --enable-libwavpack      enable wavpack encoding via libwavpack [no]
    --enable-libwebp         enable WebP encoding via libwebp [no]
@@@ -1391,20 -1175,12 +1392,21 @@@ EXTERNAL_LIBRARY_LIST=
      libopenjpeg
      libopus
      libpulse
 +    libquvi
      librtmp
      libschroedinger
 +    libshine
 +    libsmbclient
+     libsnappy
 +    libsoxr
      libspeex
 +    libssh
 +    libstagefright_h264
      libtheora
      libtwolame
 +    libutvideo
 +    libv4l2
 +    libvidstab
      libvo_aacenc
      libvo_amrwbenc
      libvorbis
@@@ -2198,9 -1863,13 +2200,12 @@@ h264_qsv_decoder_deps="libmfx
  h264_qsv_decoder_select="h264_mp4toannexb_bsf h264_parser qsvdec h264_qsv_hwaccel"
  h264_qsv_encoder_deps="libmfx"
  h264_qsv_encoder_select="qsvenc"
+ hap_decoder_select="snappy texturedsp"
+ hap_encoder_deps="libsnappy"
+ hap_encoder_select="texturedspenc"
  hevc_decoder_select="bswapdsp cabac golomb videodsp"
 -hevc_nvenc_encoder_deps="nvenc"
 -huffyuv_decoder_select="bswapdsp huffyuvdsp"
 -huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp"
 +huffyuv_decoder_select="bswapdsp huffyuvdsp llviddsp"
 +huffyuv_encoder_select="bswapdsp huffman huffyuvencdsp llviddsp"
  iac_decoder_select="imc_decoder"
  imc_decoder_select="bswapdsp fft mdct sinewin"
  indeo3_decoder_select="hpeldsp"
@@@ -5110,38 -4302,21 +5115,39 @@@ enabled libgsm            && { for gsm_
                                 done || die "ERROR: libgsm not found"; }
  enabled libilbc           && require libilbc ilbc.h WebRtcIlbcfix_InitDecode -lilbc
  enabled libmfx            && require_pkg_config libmfx "mfx/mfxvideo.h" MFXInit
 +enabled libmodplug        && require_pkg_config libmodplug libmodplug/modplug.h ModPlug_Load
  enabled libmp3lame        && require "libmp3lame >= 3.98.3" lame/lame.h lame_set_VBR_quality -lmp3lame
 +enabled libnut            && require libnut libnut.h nut_demuxer_init -lnut
  enabled libopencore_amrnb && require libopencore_amrnb opencore-amrnb/interf_dec.h Decoder_Interface_init -lopencore-amrnb
  enabled libopencore_amrwb && require libopencore_amrwb opencore-amrwb/dec_if.h D_IF_init -lopencore-amrwb
 -enabled libopencv         && require_pkg_config opencv opencv/cv.h cvCreateImageHeader
 +enabled libopencv         && require_pkg_config opencv opencv/cxcore.h cvCreateImageHeader
  enabled libopenh264       && require_pkg_config openh264 wels/codec_api.h WelsGetCodecVersion
 -enabled libopenjpeg       && { { check_header openjpeg.h && check_lib2 openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC; } ||
 -                               { require_pkg_config libopenjpeg1 openjpeg.h opj_version -DOPJ_STATIC; } }
 +enabled libopenjpeg       && { check_lib openjpeg.h opj_version -lopenmj2 -DOPJ_STATIC ||
 +                               check_lib openjpeg-1.5/openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC ||
 +                               check_lib openjpeg.h opj_version -lopenjpeg -DOPJ_STATIC ||
 +                               die "ERROR: libopenjpeg not found"; }
  enabled libopus           && require_pkg_config opus opus_multistream.h opus_multistream_decoder_create
 -enabled libpulse          && require_pkg_config libpulse-simple pulse/simple.h pa_simple_new
 +enabled libpulse          && require_pkg_config libpulse pulse/pulseaudio.h pa_context_new
 +enabled libquvi           && require_pkg_config libquvi quvi/quvi.h quvi_init
  enabled librtmp           && require_pkg_config librtmp librtmp/rtmp.h RTMP_Socket
  enabled libschroedinger   && require_pkg_config schroedinger-1.0 schroedinger/schro.h schro_init
 +enabled libshine          && require_pkg_config shine shine/layer3.h shine_encode_buffer
 +enabled libsmbclient      && { use_pkg_config smbclient libsmbclient.h smbc_init ||
 +                               require smbclient libsmbclient.h smbc_init -lsmbclient; }
+ enabled libsnappy         && require snappy snappy-c.h snappy_compress -lsnappy
 +enabled libsoxr           && require libsoxr soxr.h soxr_create -lsoxr
 +enabled libssh            && require_pkg_config libssh libssh/sftp.h sftp_init
  enabled libspeex          && require_pkg_config speex speex/speex.h speex_decoder_init -lspeex
 +enabled libstagefright_h264 && require_cpp libstagefright_h264 "binder/ProcessState.h media/stagefright/MetaData.h
 +    media/stagefright/MediaBufferGroup.h media/stagefright/MediaDebug.h media/stagefright/MediaDefs.h
 +    media/stagefright/OMXClient.h media/stagefright/OMXCodec.h" android::OMXClient -lstagefright -lmedia -lutils -lbinder -lgnustl_static
  enabled libtheora         && require libtheora theora/theoraenc.h th_info_init -ltheoraenc -ltheoradec -logg
 -enabled libtwolame        && require libtwolame twolame.h twolame_init -ltwolame
 +enabled libtwolame        && require libtwolame twolame.h twolame_init -ltwolame &&
 +                             { check_lib twolame.h twolame_encode_buffer_float32_interleaved -ltwolame ||
 +                               die "ERROR: libtwolame must be installed and version must be >= 0.3.10"; }
 +enabled libutvideo        && require_cpp utvideo "stdint.h stdlib.h utvideo/utvideo.h utvideo/Codec.h" 'CCodec*' -lutvideo -lstdc++
 +enabled libv4l2           && require_pkg_config libv4l2 libv4l2.h v4l2_ioctl
 +enabled libvidstab        && require_pkg_config "vidstab >= 0.98" vid.stab/libvidstab.h vsMotionDetectInit
  enabled libvo_aacenc      && require libvo_aacenc vo-aacenc/voAAC.h voGetAACEncAPI -lvo-aacenc
  enabled libvo_amrwbenc    && require libvo_amrwbenc vo-amrwbenc/enc_if.h E_IF_init -lvo-amrwbenc
  enabled libvorbis         && require libvorbis vorbis/vorbisenc.h vorbis_info_init -lvorbisenc -lvorbis -logg
@@@ -479,11 -424,11 +479,12 @@@ library
      @tab Tiertex .seq files used in the DOS CD-ROM version of the game Flashback.
  @item True Audio                @tab   @tab X
  @item VC-1 test bitstream       @tab X @tab X
+ @item Vidvox Hap                @tab X @tab X
 +@item Vivo                      @tab   @tab X
  @item WAV                       @tab X @tab X
 -@item WavPack                   @tab   @tab X
 +@item WavPack                   @tab X @tab X
  @item WebM                      @tab X @tab X
 -@item Windows Televison (WTV)   @tab   @tab X
 +@item Windows Televison (WTV)   @tab X @tab X
  @item Wing Commander III movie  @tab   @tab X
      @tab Multimedia format used in Origin's Wing Commander III computer game.
  @item Westwood Studios audio    @tab   @tab X
@@@ -277,9 -232,11 +277,11 @@@ OBJS-$(CONFIG_H264_DECODER)            
                                            h264_mb.o h264_picture.o h264_ps.o \
                                            h264_refs.o h264_sei.o h264_slice.o
  OBJS-$(CONFIG_H264_MMAL_DECODER)       += mmaldec.o
 -OBJS-$(CONFIG_H264_NVENC_ENCODER)      += nvenc_h264.o
 +OBJS-$(CONFIG_H264_VDA_DECODER)        += vda_h264_dec.o
  OBJS-$(CONFIG_H264_QSV_DECODER)        += qsvdec_h264.o
  OBJS-$(CONFIG_H264_QSV_ENCODER)        += qsvenc_h264.o
+ OBJS-$(CONFIG_HAP_DECODER)             += hapdec.o
+ OBJS-$(CONFIG_HAP_ENCODER)             += hapenc.o
  OBJS-$(CONFIG_HEVC_DECODER)            += hevc.o hevc_mvs.o hevc_ps.o hevc_sei.o \
                                            hevc_cabac.o hevc_refs.o hevcpred.o    \
                                            hevcdsp.o hevc_filter.o
@@@ -174,13 -165,11 +174,14 @@@ void avcodec_register_all(void
      REGISTER_ENCDEC (H261,              h261);
      REGISTER_ENCDEC (H263,              h263);
      REGISTER_DECODER(H263I,             h263i);
 -    REGISTER_ENCODER(H263P,             h263p);
 +    REGISTER_ENCDEC (H263P,             h263p);
      REGISTER_DECODER(H264,              h264);
 +    REGISTER_DECODER(H264_CRYSTALHD,    h264_crystalhd);
      REGISTER_DECODER(H264_MMAL,         h264_mmal);
      REGISTER_DECODER(H264_QSV,          h264_qsv);
 +    REGISTER_DECODER(H264_VDA,          h264_vda);
 +    REGISTER_DECODER(H264_VDPAU,        h264_vdpau);
+     REGISTER_ENCDEC (HAP,               hap);
      REGISTER_DECODER(HEVC,              hevc);
      REGISTER_DECODER(HNM4_VIDEO,        hnm4_video);
      REGISTER_DECODER(HQ_HQA,            hq_hqa);
@@@ -293,37 -296,8 +293,38 @@@ enum AVCodecID 
      AV_CODEC_ID_HQX,
      AV_CODEC_ID_TDSC,
      AV_CODEC_ID_HQ_HQA,
+     AV_CODEC_ID_HAP,
  
 +    AV_CODEC_ID_BRENDER_PIX= MKBETAG('B','P','I','X'),
 +    AV_CODEC_ID_Y41P       = MKBETAG('Y','4','1','P'),
 +    AV_CODEC_ID_ESCAPE130  = MKBETAG('E','1','3','0'),
 +    AV_CODEC_ID_EXR        = MKBETAG('0','E','X','R'),
 +    AV_CODEC_ID_AVRP       = MKBETAG('A','V','R','P'),
 +
 +    AV_CODEC_ID_012V       = MKBETAG('0','1','2','V'),
 +    AV_CODEC_ID_G2M        = MKBETAG( 0 ,'G','2','M'),
 +    AV_CODEC_ID_AVUI       = MKBETAG('A','V','U','I'),
 +    AV_CODEC_ID_AYUV       = MKBETAG('A','Y','U','V'),
 +    AV_CODEC_ID_TARGA_Y216 = MKBETAG('T','2','1','6'),
 +    AV_CODEC_ID_V308       = MKBETAG('V','3','0','8'),
 +    AV_CODEC_ID_V408       = MKBETAG('V','4','0','8'),
 +    AV_CODEC_ID_YUV4       = MKBETAG('Y','U','V','4'),
 +    AV_CODEC_ID_SANM       = MKBETAG('S','A','N','M'),
 +    AV_CODEC_ID_PAF_VIDEO  = MKBETAG('P','A','F','V'),
 +    AV_CODEC_ID_AVRN       = MKBETAG('A','V','R','n'),
 +    AV_CODEC_ID_CPIA       = MKBETAG('C','P','I','A'),
 +    AV_CODEC_ID_XFACE      = MKBETAG('X','F','A','C'),
 +    AV_CODEC_ID_SGIRLE     = MKBETAG('S','G','I','R'),
 +    AV_CODEC_ID_MVC1       = MKBETAG('M','V','C','1'),
 +    AV_CODEC_ID_MVC2       = MKBETAG('M','V','C','2'),
 +    AV_CODEC_ID_SNOW       = MKBETAG('S','N','O','W'),
 +    AV_CODEC_ID_WEBP       = MKBETAG('W','E','B','P'),
 +    AV_CODEC_ID_SMVJPEG    = MKBETAG('S','M','V','J'),
 +    AV_CODEC_ID_HEVC       = MKBETAG('H','2','6','5'),
 +#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
 +    AV_CODEC_ID_VP7        = MKBETAG('V','P','7','0'),
 +    AV_CODEC_ID_APNG       = MKBETAG('A','P','N','G'),
 +
      /* various PCM "codecs" */
      AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
      AV_CODEC_ID_PCM_S16LE = 0x10000,
Simple merge
index 0000000,1250a6f..bd0fd37
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,65 +1,65 @@@
 - * This file is part of Libav.
+ /*
+  * Vidvox Hap
+  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
+  *
 - * 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
+  */
+ #ifndef AVCODEC_HAP_H
+ #define AVCODEC_HAP_H
+ #include <stdint.h>
+ #include "libavutil/opt.h"
+ #include "bytestream.h"
+ #include "texturedsp.h"
+ typedef struct HapContext {
+     AVClass *class;
+     TextureDSPContext dxtc;
+     GetByteContext gbc;
+     PutByteContext pbc;
+     int section_type;        /* Header type */
+     int tex_rat;             /* Compression ratio */
+     const uint8_t *tex_data; /* Compressed texture */
+     uint8_t *tex_buf;        /* Uncompressed texture */
+     size_t tex_size;         /* Size of the compressed texture */
+     uint8_t *snappied;       /* Buffer interacting with snappy */
+     size_t max_snappy;       /* Maximum compressed size for snappy buffer */
+     /* Pointer to the selected compress or decompress function */
+     int (*tex_fun)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block);
+ } HapContext;
+ enum {
+     HAP_FMT_RGBDXT1   = 0x0B,
+     HAP_FMT_RGBADXT5  = 0x0E,
+     HAP_FMT_YCOCGDXT5 = 0x0F,
+ };
+ enum {
+     HAP_COMP_NONE    = 0xA0,
+     HAP_COMP_SNAPPY  = 0xB0,
+     HAP_COMP_COMPLEX = 0xC0,
+ };
+ #endif /* AVCODEC_HAP_H */
index 0000000,72db9f4..6e3c138
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,238 +1,238 @@@
 - * This file is part of Libav.
+ /*
+  * Vidvox Hap decoder
+  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
+  *
 - * 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
+  */
+ /**
+  * @file
+  * Hap decoder
+  *
+  * Fourcc: Hap1, Hap5, HapY
+  *
+  * https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
+  */
+ #include <stdint.h>
+ #include "libavutil/imgutils.h"
+ #include "avcodec.h"
+ #include "bytestream.h"
+ #include "hap.h"
+ #include "internal.h"
+ #include "snappy.h"
+ #include "texturedsp.h"
+ #include "thread.h"
+ /* The first three bytes are the size of the section past the header, or zero
+  * if the length is stored in the next long word. The fourth byte in the first
+  * long word indicates the type of the current section. */
+ static int parse_section_header(AVCodecContext *avctx)
+ {
+     HapContext *ctx = avctx->priv_data;
+     GetByteContext *gbc = &ctx->gbc;
+     int length;
+     if (bytestream2_get_bytes_left(gbc) < 4)
+         return AVERROR_INVALIDDATA;
+     length = bytestream2_get_le24(gbc);
+     ctx->section_type = bytestream2_get_byte(gbc);
+     if (length == 0) {
+         if (bytestream2_get_bytes_left(gbc) < 4)
+             return AVERROR_INVALIDDATA;
+         length = bytestream2_get_le32(gbc);
+     }
+     if (length > bytestream2_get_bytes_left(gbc) || length == 0)
+         return AVERROR_INVALIDDATA;
+     return length;
+ }
+ /* Prepare the texture to be decompressed */
+ static int setup_texture(AVCodecContext *avctx, size_t length)
+ {
+     HapContext *ctx = avctx->priv_data;
+     GetByteContext *gbc = &ctx->gbc;
+     int64_t snappy_size;
+     const char *texture_name;
+     const char *compressorstr;
+     int ret;
+     switch (ctx->section_type & 0x0F) {
+     case HAP_FMT_RGBDXT1:
+         ctx->tex_rat = 8;
+         ctx->tex_fun = ctx->dxtc.dxt1_block;
+         texture_name = "DXT1";
+         break;
+     case HAP_FMT_RGBADXT5:
+         ctx->tex_rat = 16;
+         ctx->tex_fun = ctx->dxtc.dxt5_block;
+         texture_name = "DXT5";
+         break;
+     case HAP_FMT_YCOCGDXT5:
+         ctx->tex_rat = 16;
+         ctx->tex_fun = ctx->dxtc.dxt5ys_block;
+         texture_name = "DXT5-YCoCg-scaled";
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR,
+                "Invalid format mode %02X.\n", ctx->section_type);
+         return AVERROR_INVALIDDATA;
+     }
+     switch (ctx->section_type & 0xF0) {
+     case HAP_COMP_NONE:
+         /* Only DXTC texture compression */
+         ctx->tex_data = gbc->buffer;
+         ctx->tex_size = length;
+         compressorstr = "none";
+         break;
+     case HAP_COMP_SNAPPY:
+         /* Uncompress the frame */
+         ret = ff_snappy_uncompress(gbc, &ctx->snappied, &snappy_size);
+         if (ret < 0) {
+              av_log(avctx, AV_LOG_ERROR, "Snappy uncompress error\n");
+              return ret;
+         }
+         ctx->tex_data = ctx->snappied;
+         ctx->tex_size = snappy_size;
+         compressorstr = "snappy";
+         break;
+     case HAP_COMP_COMPLEX:
+         compressorstr = "complex";
+         avpriv_request_sample(avctx, "Complex Hap compressor");
+         return AVERROR_PATCHWELCOME;
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR,
+                "Invalid compressor mode %02X.\n", ctx->section_type);
+         return AVERROR_INVALIDDATA;
+     }
+     av_log(avctx, AV_LOG_DEBUG, "%s texture with %s compressor\n",
+            texture_name, compressorstr);
+     return 0;
+ }
+ static int decompress_texture_thread(AVCodecContext *avctx, void *arg,
+                                      int block_nb, int thread_nb)
+ {
+     HapContext *ctx = avctx->priv_data;
+     AVFrame *frame = arg;
+     int x = (TEXTURE_BLOCK_W * block_nb) % avctx->coded_width;
+     int y = TEXTURE_BLOCK_H * (TEXTURE_BLOCK_W * block_nb / avctx->coded_width);
+     uint8_t *p = frame->data[0] + x * 4 + y * frame->linesize[0];
+     const uint8_t *d = ctx->tex_data + block_nb * ctx->tex_rat;
+     ctx->tex_fun(p, frame->linesize[0], d);
+     return 0;
+ }
+ static int hap_decode(AVCodecContext *avctx, void *data,
+                       int *got_frame, AVPacket *avpkt)
+ {
+     HapContext *ctx = avctx->priv_data;
+     ThreadFrame tframe;
+     int ret, length;
+     int blocks = avctx->coded_width * avctx->coded_height / (TEXTURE_BLOCK_W * TEXTURE_BLOCK_H);
+     bytestream2_init(&ctx->gbc, avpkt->data, avpkt->size);
+     /* Check for section header */
+     length = parse_section_header(avctx);
+     if (length < 0) {
+         av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n");
+         return length;
+     }
+     /* Prepare the texture buffer and decompress function */
+     ret = setup_texture(avctx, length);
+     if (ret < 0)
+         return ret;
+     /* Get the output frame ready to receive data */
+     tframe.f = data;
+     ret = ff_thread_get_buffer(avctx, &tframe, 0);
+     if (ret < 0)
+         return ret;
+     ff_thread_finish_setup(avctx);
+     /* Use the decompress function on the texture, one block per thread */
+     avctx->execute2(avctx, decompress_texture_thread, tframe.f, NULL, blocks);
+     /* Frame is ready to be output */
+     tframe.f->pict_type = AV_PICTURE_TYPE_I;
+     tframe.f->key_frame = 1;
+     *got_frame = 1;
+     return avpkt->size;
+ }
+ static av_cold int hap_init(AVCodecContext *avctx)
+ {
+     HapContext *ctx = avctx->priv_data;
+     int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
+     if (ret < 0) {
+         av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n",
+                avctx->width, avctx->height);
+         return ret;
+     }
+     /* Since codec is based on 4x4 blocks, size is aligned to 4 */
+     avctx->coded_width  = FFALIGN(avctx->width,  TEXTURE_BLOCK_W);
+     avctx->coded_height = FFALIGN(avctx->height, TEXTURE_BLOCK_H);
+     /* Technically only one mode has alpha, but 32 bits are easier to handle */
+     avctx->pix_fmt = AV_PIX_FMT_RGBA;
+     ff_texturedsp_init(&ctx->dxtc);
+     return 0;
+ }
+ static av_cold int hap_close(AVCodecContext *avctx)
+ {
+     HapContext *ctx = avctx->priv_data;
+     av_freep(&ctx->snappied);
+     return 0;
+ }
+ AVCodec ff_hap_decoder = {
+     .name           = "hap",
+     .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap decoder"),
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_HAP,
+     .init           = hap_init,
+     .decode         = hap_decode,
+     .close          = hap_close,
+     .priv_data_size = sizeof(HapContext),
+     .capabilities   = CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS |
+                       CODEC_CAP_DR1,
+     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
+                       FF_CODEC_CAP_INIT_CLEANUP,
+ };
index 0000000,d828a09..4434a1e
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,204 +1,204 @@@
 - * This file is part of Libav.
+ /*
+  * Vidvox Hap encoder
+  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
+  *
 - * 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
+  */
+ /**
+  * @file
+  * Hap encoder
+  *
+  * Fourcc: Hap1, Hap5, HapY
+  *
+  * https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
+  */
+ #include <stdint.h>
+ #include "snappy-c.h"
+ #include "libavutil/frame.h"
+ #include "libavutil/imgutils.h"
+ #include "libavutil/intreadwrite.h"
+ #include "libavutil/opt.h"
+ #include "avcodec.h"
+ #include "bytestream.h"
+ #include "hap.h"
+ #include "internal.h"
+ #include "texturedsp.h"
+ /* A fixed header size allows to skip a memcpy */
+ #define HEADER_SIZE 8
+ static void compress_texture(AVCodecContext *avctx, const AVFrame *f)
+ {
+     HapContext *ctx = avctx->priv_data;
+     uint8_t *out = ctx->tex_buf;
+     int i, j;
+     for (j = 0; j < avctx->height; j += 4) {
+         for (i = 0; i < avctx->width; i += 4) {
+             uint8_t *p = f->data[0] + i * 4 + j * f->linesize[0];
+             const int step = ctx->tex_fun(out, f->linesize[0], p);
+             out += step;
+         }
+     }
+ }
+ static int hap_encode(AVCodecContext *avctx, AVPacket *pkt,
+                       const AVFrame *frame, int *got_packet)
+ {
+     HapContext *ctx = avctx->priv_data;
+     size_t final_size = ctx->max_snappy;
+     int ret, comp = HAP_COMP_SNAPPY;
+     int pktsize = FFMAX(ctx->tex_size, ctx->max_snappy) + HEADER_SIZE;
+     /* Allocate maximum size packet, shrink later. */
+     ret = ff_alloc_packet(pkt, pktsize);
+     if (ret < 0)
+         return ret;
+     /* DXTC compression. */
+     compress_texture(avctx, frame);
+     /* Compress with snappy too, write directly on packet buffer. */
+     ret = snappy_compress(ctx->tex_buf, ctx->tex_size,
+                           pkt->data + HEADER_SIZE, &final_size);
+     if (ret != SNAPPY_OK) {
+         av_log(avctx, AV_LOG_ERROR, "Snappy compress error.\n");
+         return AVERROR_BUG;
+     }
+     /* If there is no gain from snappy, just use the raw texture. */
+     if (final_size > ctx->tex_size) {
+         comp = HAP_COMP_NONE;
+         av_log(avctx, AV_LOG_VERBOSE,
+                "Snappy buffer bigger than uncompressed (%lu > %lu bytes).\n",
+                final_size, ctx->tex_size);
+         memcpy(pkt->data + HEADER_SIZE, ctx->tex_buf, ctx->tex_size);
+         final_size = ctx->tex_size;
+     }
+     /* Write header at the start. */
+     AV_WL24(pkt->data, 0);
+     AV_WL32(pkt->data + 4, final_size);
+     pkt->data[3] = comp | ctx->section_type;
+     av_shrink_packet(pkt, final_size + HEADER_SIZE);
+     pkt->flags |= AV_PKT_FLAG_KEY;
+     *got_packet = 1;
+     return 0;
+ }
+ static av_cold int hap_init(AVCodecContext *avctx)
+ {
+     HapContext *ctx = avctx->priv_data;
+     int ratio;
+     int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
+     if (ret < 0) {
+         av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n",
+                avctx->width, avctx->height);
+         return ret;
+     }
+     if (avctx->width % 4 || avctx->height % 4) {
+         av_log(avctx, AV_LOG_ERROR, "Video size %dx%d is not multiple of 4.\n",
+                avctx->width, avctx->height);
+         return AVERROR_INVALIDDATA;
+     }
+     ff_texturedspenc_init(&ctx->dxtc);
+     switch (ctx->section_type & 0x0F) {
+     case HAP_FMT_RGBDXT1:
+         ratio = 8;
+         avctx->codec_tag = MKTAG('H', 'a', 'p', '1');
+         ctx->tex_fun = ctx->dxtc.dxt1_block;
+         break;
+     case HAP_FMT_RGBADXT5:
+         ratio = 4;
+         avctx->codec_tag = MKTAG('H', 'a', 'p', '5');
+         ctx->tex_fun = ctx->dxtc.dxt5_block;
+         break;
+     case HAP_FMT_YCOCGDXT5:
+         ratio = 4;
+         avctx->codec_tag = MKTAG('H', 'a', 'p', 'Y');
+         ctx->tex_fun = ctx->dxtc.dxt5ys_block;
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "Invalid format %02X\n", ctx->section_type);
+         return AVERROR_INVALIDDATA;
+     }
+     /* Texture compression ratio is constant, so can we computer
+      * beforehand the final size of the uncompressed buffer. */
+     ctx->tex_size   = FFALIGN(avctx->width,  TEXTURE_BLOCK_W) *
+                       FFALIGN(avctx->height, TEXTURE_BLOCK_H) * 4 / ratio;
+     ctx->max_snappy = snappy_max_compressed_length(ctx->tex_size);
+     ctx->tex_buf  = av_malloc(ctx->tex_size);
+     if (!ctx->tex_buf)
+         return AVERROR(ENOMEM);
+     return 0;
+ }
+ static av_cold int hap_close(AVCodecContext *avctx)
+ {
+     HapContext *ctx = avctx->priv_data;
+     av_freep(&ctx->tex_buf);
+     return 0;
+ }
+ #define OFFSET(x) offsetof(HapContext, x)
+ #define FLAGS     AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
+ static const AVOption options[] = {
+     { "format", NULL, OFFSET(section_type), AV_OPT_TYPE_INT, { .i64 = HAP_FMT_RGBDXT1 }, HAP_FMT_RGBDXT1, HAP_FMT_YCOCGDXT5, FLAGS, "format" },
+         { "hap",       "Hap 1 (DXT1 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBDXT1   }, 0, 0, FLAGS, "format" },
+         { "hap_alpha", "Hap Alpha (DXT5 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBADXT5  }, 0, 0, FLAGS, "format" },
+         { "hap_q",     "Hap Q (DXT5-YCoCg textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_YCOCGDXT5 }, 0, 0, FLAGS, "format" },
+     { NULL },
+ };
+ static const AVClass hapenc_class = {
+     .class_name = "Hap encoder",
+     .item_name  = av_default_item_name,
+     .option     = options,
+     .version    = LIBAVUTIL_VERSION_INT,
+ };
+ AVCodec ff_hap_encoder = {
+     .name           = "hap",
+     .long_name      = NULL_IF_CONFIG_SMALL("Vidvox Hap encoder"),
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_HAP,
+     .priv_data_size = sizeof(HapContext),
+     .priv_class     = &hapenc_class,
+     .init           = hap_init,
+     .encode2        = hap_encode,
+     .close          = hap_close,
+     .pix_fmts       = (const enum AVPixelFormat[]) {
+         AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE,
+     },
+     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
+                       FF_CODEC_CAP_INIT_CLEANUP,
+ };
@@@ -29,8 -29,8 +29,8 @@@
  #include "libavutil/version.h"
  
  #define LIBAVCODEC_VERSION_MAJOR 56
- #define LIBAVCODEC_VERSION_MINOR  42
- #define LIBAVCODEC_VERSION_MICRO 101
 -#define LIBAVCODEC_VERSION_MINOR 27
 -#define LIBAVCODEC_VERSION_MICRO  0
++#define LIBAVCODEC_VERSION_MINOR  43
++#define LIBAVCODEC_VERSION_MICRO 100
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \
Simple merge
@@@ -156,18 -148,30 +156,30 @@@ fate-flic-af12: CMD = framecrc -i $(TAR
  FATE_FLIC += fate-flic-magiccarpet
  fate-flic-magiccarpet: CMD = framecrc -i $(TARGET_SAMPLES)/fli/intel.dat -pix_fmt rgb24
  
 -FATE_SAMPLES_AVCONV-$(call DEMDEC, FLIC, FLIC) += $(FATE_FLIC)
 +FATE_VIDEO-$(call DEMDEC, FLIC, FLIC) += $(FATE_FLIC)
  fate-flic: $(FATE_FLIC)
  
 -FATE_SAMPLES_AVCONV-$(call DEMDEC, AVI, FRWU) += fate-frwu
 +FATE_VIDEO-$(call DEMDEC, AVI, FRWU) += fate-frwu
  fate-frwu: CMD = framecrc -i $(TARGET_SAMPLES)/frwu/frwu.avi
  
 -FATE_SAMPLES_AVCONV-$(call DEMDEC, IDCIN, IDCIN) += fate-id-cin-video
 +FATE_VIDEO-$(call DEMDEC, IDCIN, IDCIN) += fate-id-cin-video
  fate-id-cin-video: CMD = framecrc -i $(TARGET_SAMPLES)/idcin/idlog-2MB.cin -pix_fmt rgb24
  
 -FATE_SAMPLES_AVCONV-$(call ENCDEC, ROQ PGMYUV, ROQ IMAGE2) += fate-idroq-video-encode
 -fate-idroq-video-encode: CMD = md5 -f image2 -vcodec pgmyuv -i $(TARGET_SAMPLES)/ffmpeg-synthetic/vsynth1/%02d.pgm -sws_flags +bitexact -vf pad=512:512:80:112 -f roq -t 0.2
 +FATE_VIDEO-$(call ENCDEC, ROQ PGMYUV, ROQ IMAGE2) += fate-idroq-video-encode
 +fate-idroq-video-encode: CMD = md5 -f image2 -vcodec pgmyuv -i $(TARGET_SAMPLES)/ffmpeg-synthetic/vsynth1/%02d.pgm -r 30 -sws_flags +bitexact -vf pad=512:512:80:112 -f roq -t 0.2
  
+ FATE_HAP += fate-hap1
+ fate-hap1: CMD = framecrc -i $(TARGET_SAMPLES)/hap/hap1.mov
+ FATE_HAP += fate-hap5
+ fate-hap5: CMD = framecrc -i $(TARGET_SAMPLES)/hap/hap5.mov
+ FATE_HAP += fate-hapy
+ fate-hapy: CMD = framecrc -i $(TARGET_SAMPLES)/hap/hapy.mov
+ FATE_SAMPLES_AVCONV-$(call DEMDEC, MOV, HAP) += $(FATE_HAP)
+ fate-hap: $(FATE_HAP)
  FATE_IFF-$(CONFIG_IFF_BYTERUN1_DECODER) += fate-iff-byterun1
  fate-iff-byterun1: CMD = framecrc -i $(TARGET_SAMPLES)/iff/ASH.LBM -pix_fmt rgb24
  
index 0000000,0cabf8b..d3bdeae
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,2 +1,2 @@@
 -#tb 0: 1/2997
 -0,          0,          0,        0,  1228800, 0x0fa946bc
++#tb 0: 62/2997
++0,          0,          0,        1,  1228800, 0x0fa946bc
index 0000000,a582c39..458981e
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,2 +1,2 @@@
 -#tb 0: 1/3000
 -0,          0,          0,        0,  1228800, 0xb71ecf93
++#tb 0: 1/30
++0,          0,          0,        1,  1228800, 0xb71ecf93
index 0000000,e6dd4f5..e7d7608
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,2 +1,2 @@@
 -#tb 0: 1/2997
 -0,          0,          0,        0,  1228800, 0x5993522d
++#tb 0: 62/2997
++0,          0,          0,        1,  1228800, 0x5993522d