Merge remote-tracking branch 'qatar/master'

* qatar/master:
  x86: dsputil: prettyprint gcc inline asm
  x86: K&R prettyprinting cosmetics for dsputil_mmx.c
  x86: conditionally compile H.264 QPEL optimizations
  dsputil_mmx: Surround QPEL macros by "do { } while (0);" blocks.
  Ignore generated files below doc/.
  dpcm: convert to bytestream2.
  interplayvideo: convert to bytestream2.
  movenc: Merge if statements
  h264: fix memleak in error path.
  pthread: Immediately release all frames in ff_thread_flush()
  h264: Add check for invalid chroma_format_idc
  utvideo: port header reading to bytestream2.

Conflicts:
	.gitignore
	configure
	libavcodec/h264_ps.c
	libavcodec/interplayvideo.c
	libavcodec/pthread.c
	libavcodec/x86/dsputil_mmx.c
Merged-by: Michael Niedermayer <michaelni@gmx.at>

.gitignore

@@ -22,6 +22,9 @@ ffplay
 ffprobe
 ffserver
 avconv
+doc/avoptions_codec.texi
+doc/avoptions_format.texi
+doc/print_options
 libavcodec/*_tablegen
 libavcodec/*_tables.c
 libavcodec/*_tables.h

configure

@@ -1266,6 +1266,7 @@ CONFIG_EXTRA="
     h264chroma
     h264dsp
     h264pred
+    h264qpel
     huffman
     lgplv3
     lpc
@@ -1424,7 +1425,7 @@ h263_vaapi_hwaccel_select="vaapi h263_decoder"
 h263i_decoder_select="h263_decoder"
 h263p_encoder_select="h263_encoder"
 h264_crystalhd_decoder_select="crystalhd h264_mp4toannexb_bsf h264_parser"
-h264_decoder_select="golomb h264chroma h264dsp h264pred"
+h264_decoder_select="golomb h264chroma h264dsp h264pred h264qpel"
 h264_dxva2_hwaccel_deps="dxva2api_h"
 h264_dxva2_hwaccel_select="dxva2 h264_decoder"
 h264_vaapi_hwaccel_select="vaapi h264_decoder"
@@ -1485,8 +1486,8 @@ rv10_decoder_select="h263_decoder"
 rv10_encoder_select="h263_encoder"
 rv20_decoder_select="h263_decoder"
 rv20_encoder_select="h263_encoder"
-rv30_decoder_select="golomb h264chroma h264pred"
-rv40_decoder_select="golomb h264chroma h264pred"
+rv30_decoder_select="golomb h264chroma h264pred h264qpel"
+rv40_decoder_select="golomb h264chroma h264pred h264qpel"
 shorten_decoder_select="golomb"
 sipr_decoder_select="lsp"
 snow_decoder_select="dwt"
@@ -1495,7 +1496,7 @@ sonic_decoder_select="golomb"
 sonic_encoder_select="golomb"
 sonic_ls_encoder_select="golomb"
 svq1_encoder_select="aandct"
-svq3_decoder_select="golomb h264chroma h264dsp h264pred"
+svq3_decoder_select="golomb h264chroma h264dsp h264pred h264qpel"
 svq3_decoder_suggest="zlib"
 theora_decoder_select="vp3_decoder"
 tiff_decoder_suggest="zlib"
@@ -1504,7 +1505,7 @@ truehd_decoder_select="mlp_decoder"
 tscc_decoder_select="zlib"
 twinvq_decoder_select="mdct lsp sinewin"
 vc1_crystalhd_decoder_select="crystalhd"
-vc1_decoder_select="h263_decoder h264chroma"
+vc1_decoder_select="h263_decoder h264chroma h264qpel"
 vc1_dxva2_hwaccel_deps="dxva2api_h"
 vc1_dxva2_hwaccel_select="dxva2 vc1_decoder"
 vc1_vaapi_hwaccel_select="vaapi vc1_decoder"
@@ -1515,7 +1516,7 @@ vorbis_encoder_select="mdct"
 vp6_decoder_select="huffman"
 vp6a_decoder_select="vp6_decoder"
 vp6f_decoder_select="vp6_decoder"
-vp8_decoder_select="h264pred"
+vp8_decoder_select="h264pred h264qpel"
 wmapro_decoder_select="mdct sinewin"
 wmav1_decoder_select="mdct sinewin"
 wmav1_encoder_select="mdct sinewin"
@@ -1544,7 +1545,7 @@ vda_deps="VideoDecodeAcceleration_VDADecoder_h pthreads"
 vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"
 
 # parsers
-h264_parser_select="golomb h264chroma h264dsp h264pred"
+h264_parser_select="golomb h264chroma h264dsp h264pred h264qpel"
 
 # external libraries
 libaacplus_encoder_deps="libaacplus"

libavcodec/dpcm.c

@@ -40,6 +40,7 @@
 #include "libavutil/intreadwrite.h"
 #include "avcodec.h"
 #include "bytestream.h"
+#include "mathops.h"
 
 typedef struct DPCMContext {
     AVFrame frame;
@@ -173,20 +174,18 @@ static av_cold int dpcm_decode_init(AVCodecContext *avctx)
 static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
                              int *got_frame_ptr, AVPacket *avpkt)
 {
-    const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
-    const uint8_t *buf_end = buf + buf_size;
     DPCMContext *s = avctx->priv_data;
     int out = 0, ret;
     int predictor[2];
     int ch = 0;
     int stereo = s->channels - 1;
-    int16_t *output_samples;
+    int16_t *output_samples, *samples_end;
+    GetByteContext gb;
 
-    if (stereo && (buf_size & 1)) {
+    if (stereo && (buf_size & 1))
         buf_size--;
-        buf_end--;
-    }
+    bytestream2_init(&gb, avpkt->data, buf_size);
 
     /* calculate output size */
     switch(avctx->codec->id) {
@@ -221,22 +220,23 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
         return ret;
     }
     output_samples = (int16_t *)s->frame.data[0];
+    samples_end = output_samples + out;
 
     switch(avctx->codec->id) {
 
     case CODEC_ID_ROQ_DPCM:
-        buf += 6;
+        bytestream2_skipu(&gb, 6);
 
         if (stereo) {
-            predictor[1] = (int16_t)(bytestream_get_byte(&buf) << 8);
-            predictor[0] = (int16_t)(bytestream_get_byte(&buf) << 8);
+            predictor[1] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
+            predictor[0] = sign_extend(bytestream2_get_byteu(&gb) << 8, 16);
         } else {
-            predictor[0] = (int16_t)bytestream_get_le16(&buf);
+            predictor[0] = sign_extend(bytestream2_get_le16u(&gb), 16);
         }
 
         /* decode the samples */
-        while (buf < buf_end) {
-            predictor[ch] += s->roq_square_array[*buf++];
+        while (output_samples < samples_end) {
+            predictor[ch] += s->roq_square_array[bytestream2_get_byteu(&gb)];
             predictor[ch]  = av_clip_int16(predictor[ch]);
             *output_samples++ = predictor[ch];
 
@@ -246,16 +246,16 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
         break;
 
     case CODEC_ID_INTERPLAY_DPCM:
-        buf += 6;  /* skip over the stream mask and stream length */
+        bytestream2_skipu(&gb, 6);  /* skip over the stream mask and stream length */
 
         for (ch = 0; ch < s->channels; ch++) {
-            predictor[ch] = (int16_t)bytestream_get_le16(&buf);
+            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
             *output_samples++ = predictor[ch];
         }
 
         ch = 0;
-        while (buf < buf_end) {
-            predictor[ch] += interplay_delta_table[*buf++];
+        while (output_samples < samples_end) {
+            predictor[ch] += interplay_delta_table[bytestream2_get_byteu(&gb)];
             predictor[ch]  = av_clip_int16(predictor[ch]);
             *output_samples++ = predictor[ch];
 
@@ -269,16 +269,19 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
         int shift[2] = { 4, 4 };
 
         for (ch = 0; ch < s->channels; ch++)
-            predictor[ch] = (int16_t)bytestream_get_le16(&buf);
+            predictor[ch] = sign_extend(bytestream2_get_le16u(&gb), 16);
 
         ch = 0;
-        while (buf < buf_end) {
-            uint8_t n = *buf++;
-            int16_t diff = (n & 0xFC) << 8;
-            if ((n & 0x03) == 3)
+        while (output_samples < samples_end) {
+            int diff = bytestream2_get_byteu(&gb);
+            int n    = diff & 3;
+
+            if (n == 3)
                 shift[ch]++;
             else
-                shift[ch] -= (2 * (n & 3));
+                shift[ch] -= (2 * n);
+            diff = sign_extend((diff &~ 3) << 8, 16);
+
             /* saturate the shifter to a lower limit of 0 */
             if (shift[ch] < 0)
                 shift[ch] = 0;
@@ -296,9 +299,10 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
     }
     case CODEC_ID_SOL_DPCM:
         if (avctx->codec_tag != 3) {
-            uint8_t *output_samples_u8 = s->frame.data[0];
-            while (buf < buf_end) {
-                uint8_t n = *buf++;
+            uint8_t *output_samples_u8 = s->frame.data[0],
+                    *samples_end_u8 = output_samples_u8 + out;
+            while (output_samples_u8 < samples_end_u8) {
+                int n = bytestream2_get_byteu(&gb);
 
                 s->sample[0] += s->sol_table[n >> 4];
                 s->sample[0]  = av_clip_uint8(s->sample[0]);
@@ -309,8 +313,8 @@ static int dpcm_decode_frame(AVCodecContext *avctx, void *data,
                 *output_samples_u8++ = s->sample[stereo];
             }
         } else {
-            while (buf < buf_end) {
-                uint8_t n = *buf++;
+            while (output_samples < samples_end) {
+                int n = bytestream2_get_byteu(&gb);
                 if (n & 0x80) s->sample[ch] -= sol_table_16[n & 0x7F];
                 else          s->sample[ch] += sol_table_16[n & 0x7F];
                 s->sample[ch] = av_clip_int16(s->sample[ch]);

libavcodec/h264_ps.c

@@ -352,9 +352,9 @@ int ff_h264_decode_seq_parameter_set(H264Context *h){
         if (sps->chroma_format_idc > 3U) {
             av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
             goto fail;
-        }
-        if(sps->chroma_format_idc == 3)
+        } else if(sps->chroma_format_idc == 3) {
             sps->residual_color_transform_flag = get_bits1(&s->gb);
+        }
         sps->bit_depth_luma   = get_ue_golomb(&s->gb) + 8;
         sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
         if (sps->bit_depth_luma > 12U || sps->bit_depth_chroma > 12U) {

libavcodec/pthread.c

@@ -907,9 +907,13 @@ void ff_thread_flush(AVCodecContext *avctx)
     fctx->next_decoding = fctx->next_finished = 0;
     fctx->delaying = 1;
     fctx->prev_thread = NULL;
-    // Make sure decode flush calls with size=0 won't return old frames
-    for (i = 0; i < avctx->thread_count; i++)
-        fctx->threads[i].got_frame = 0;
+    for (i = 0; i < avctx->thread_count; i++) {
+        PerThreadContext *p = &fctx->threads[i];
+        // Make sure decode flush calls with size=0 won't return old frames
+        p->got_frame = 0;
+
+        release_delayed_buffers(p);
+    }
 }
 
 static int *allocate_progress(PerThreadContext *p)

libavcodec/utvideo.c

@@ -358,13 +358,12 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
 {
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
-    const uint8_t *buf_end = buf + buf_size;
     UtvideoContext *c = avctx->priv_data;
-    const uint8_t *ptr;
     int i, j;
     const uint8_t *plane_start[5];
     int plane_size, max_slice_size = 0, slice_start, slice_end, slice_size;
     int ret;
+    GetByteContext gb;
 
     if (c->pic.data[0])
         ff_thread_release_buffer(avctx, &c->pic);
@@ -377,20 +376,21 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
     }
 
     /* parse plane structure to retrieve frame flags and validate slice offsets */
-    ptr = buf;
+    bytestream2_init(&gb, buf, buf_size);
     for (i = 0; i < c->planes; i++) {
-        plane_start[i] = ptr;
-        if (buf_end - ptr < 256 + 4 * c->slices) {
+        plane_start[i] = gb.buffer;
+        if (bytestream2_get_bytes_left(&gb) < 256 + 4 * c->slices) {
             av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
             return AVERROR_INVALIDDATA;
         }
-        ptr += 256;
+        bytestream2_skipu(&gb, 256);
         slice_start = 0;
         slice_end   = 0;
         for (j = 0; j < c->slices; j++) {
-            slice_end   = bytestream_get_le32(&ptr);
+            slice_end   = bytestream2_get_le32u(&gb);
             slice_size  = slice_end - slice_start;
-            if (slice_size < 0) {
+            if (slice_end <= 0 || slice_size <= 0 ||
+                bytestream2_get_bytes_left(&gb) < slice_end) {
                 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
                 return AVERROR_INVALIDDATA;
             }
@@ -398,18 +398,14 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
             max_slice_size = FFMAX(max_slice_size, slice_size);
         }
         plane_size = slice_end;
-        if (buf_end - ptr < plane_size) {
-            av_log(avctx, AV_LOG_ERROR, "Plane size is bigger than available data\n");
-            return AVERROR_INVALIDDATA;
-        }
-        ptr += plane_size;
+        bytestream2_skipu(&gb, plane_size);
     }
-    plane_start[c->planes] = ptr;
-    if (buf_end - ptr < c->frame_info_size) {
+    plane_start[c->planes] = gb.buffer;
+    if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
         av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
         return AVERROR_INVALIDDATA;
     }
-    c->frame_info = AV_RL32(ptr);
+    c->frame_info = bytestream2_get_le32u(&gb);
     av_log(avctx, AV_LOG_DEBUG, "frame information flags %X\n", c->frame_info);
 
     c->frame_pred = (c->frame_info >> 8) & 3;

libavcodec/x86/Makefile

@@ -25,6 +25,7 @@ YASM-OBJS-$(CONFIG_H264DSP)            += x86/h264_deblock.o            \
 YASM-OBJS-$(CONFIG_H264PRED)           += x86/h264_intrapred.o          \
                                           x86/h264_intrapred_10bit.o
 MMX-OBJS-$(CONFIG_H264PRED)            += x86/h264_intrapred_init.o
+YASM-OBJS-$(CONFIG_H264QPEL)           += x86/h264_qpel_10bit.o
 
 MMX-OBJS-$(CONFIG_RV30_DECODER)        += x86/rv34dsp_init.o
 YASM-OBJS-$(CONFIG_RV30_DECODER)       += x86/rv34dsp.o
@@ -71,7 +72,6 @@ MMX-OBJS-$(CONFIG_VP8_DECODER)         += x86/vp8dsp-init.o
 MMX-OBJS-$(HAVE_YASM)                  += x86/dsputil_yasm.o            \
                                           x86/deinterlace.o             \
                                           x86/fmtconvert.o              \
-                                          x86/h264_qpel_10bit.o         \
                                           $(YASM-OBJS-yes)
 
 MMX-OBJS-$(CONFIG_FFT)                 += x86/fft.o

libavformat/movenc.c

@@ -2209,14 +2209,11 @@ static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov)
                                     size);
                     av_free(ptr);
                 }
-            } else {
-                param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
-                                track->enc->extradata_size);
-            }
-            if (track->enc->codec_id == CODEC_ID_H264) {
                 param_write_string(pb, "FourCC", "H264");
             } else if (track->enc->codec_id == CODEC_ID_VC1) {
                 param_write_string(pb, "FourCC", "WVC1");
+                param_write_hex(pb, "CodecPrivateData", track->enc->extradata,
+                                track->enc->extradata_size);
             }
             param_write_int(pb, "MaxWidth", track->enc->width);
             param_write_int(pb, "MaxHeight", track->enc->height);