Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 8 Mar 2012 01:28:40 +0000 (02:28 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 8 Mar 2012 01:51:45 +0000 (02:51 +0100)
* qatar/master: (29 commits)
  sbrdsp.asm: convert all instructions to float/SSE ones.
  dv: cosmetics.
  dv: check buffer size before reading profile.
  Revert "AAC SBR: group some writes."
  udp: Print an error message if bind fails
  cook: extend channel uncoupling tables so the full bit range is covered.
  roqvideo: cosmetics.
  roqvideo: convert to bytestream2 API.
  dca: don't use av_clip_uintp2().
  wmall: fix build with -DDEBUG enabled.
  smc: port to bytestream2 API.
  AAC SBR: group some writes.
  dsputil: remove shift parameter from scalarproduct_int16
  SBR DSP: unroll sum_square
  rv34: remove dead code in intra availability check
  rv34: clean a bit availability checks.
  v4l2: update documentation
  tgq: convert to bytestream2 API.
  parser: remove forward declaration of MpegEncContext
  dca: prevent accessing static arrays with invalid indexes.
  ...

Conflicts:
doc/indevs.texi
libavcodec/Makefile
libavcodec/dca.c
libavcodec/dvdata.c
libavcodec/eatgq.c
libavcodec/mmvideo.c
libavcodec/roqvideodec.c
libavcodec/smc.c
libswscale/output.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
37 files changed:
1  2 
doc/indevs.texi
libavcodec/Makefile
libavcodec/acelp_pitch_delay.c
libavcodec/arm/dsputil_init_neon.c
libavcodec/arm/int_neon.S
libavcodec/cook.c
libavcodec/cookdata.h
libavcodec/dca.c
libavcodec/dcadata.h
libavcodec/dsputil.c
libavcodec/dsputil.h
libavcodec/dvdata.c
libavcodec/eatgq.c
libavcodec/g729postfilter.c
libavcodec/mmvideo.c
libavcodec/parser.h
libavcodec/pcm-mpeg.c
libavcodec/rawdec.c
libavcodec/roqvideo.h
libavcodec/roqvideodec.c
libavcodec/rv34.c
libavcodec/smc.c
libavcodec/vc1.c
libavcodec/vc1.h
libavcodec/vc1acdata.h
libavcodec/vc1data.c
libavcodec/vc1data.h
libavcodec/vc1dec.c
libavcodec/wma.c
libavcodec/wma.h
libavcodec/wmalosslessdec.c
libavcodec/wmaprodec.c
libavcodec/x86/dsputil_yasm.asm
libavcodec/x86/h264_qpel_mmx.c
libavformat/smacker.c
libavformat/udp.c
libswscale/output.c

diff --cc doc/indevs.texi
@@@ -498,15 -248,15 +498,15 @@@ The filename to provide to the input de
  representing the sndio input device, and is usually set to
  @file{/dev/audio0}.
  
 -For example to grab from @file{/dev/audio0} using @command{avconv} use the
 +For example to grab from @file{/dev/audio0} using @command{ffmpeg} use the
  command:
  @example
 -avconv -f sndio -i /dev/audio0 /tmp/oss.wav
 +ffmpeg -f sndio -i /dev/audio0 /tmp/oss.wav
  @end example
  
- @section video4linux and video4linux2
+ @section video4linux2
  
- Video4Linux and Video4Linux2 input video devices.
+ Video4Linux2 input video device.
  
  The name of the device to grab is a file device node, usually Linux
  systems tend to automatically create such nodes when the device
  kind @file{/dev/video@var{N}}, where @var{N} is a number associated to
  the device.
  
- Video4Linux and Video4Linux2 devices only support a limited set of
+ Video4Linux2 devices usually support a limited set of
  @var{width}x@var{height} sizes and framerates. You can check which are
- supported for example with the command @command{dov4l} for Video4Linux
- devices and using @command{-list_formats all} for Video4Linux2 devices.
+ supported using @command{-list_formats all} for Video4Linux2 devices.
  
- If the size for the device is set to 0x0, the input device will
- try to auto-detect the size to use.
- Only for the video4linux2 device, if the frame rate is set to 0/0 the
- input device will use the frame rate value already set in the driver.
- Video4Linux support is deprecated since Linux 2.6.30, and will be
- dropped in later versions.
 -Some usage examples of the video4linux2 devices with avconv and avplay:
++Some usage examples of the video4linux2 devices with ffmpeg and ffplay:
  
- Follow some usage examples of the video4linux devices with the ff*
- tools.
 +Note that if FFmpeg is build with v4l-utils support ("--enable-libv4l2"
 +option), it will always be used.
  @example
- # Grab and show the input of a video4linux device, frame rate is set
- # to the default of 25/1.
- ffplay -s 320x240 -f video4linux /dev/video0
- # Grab and show the input of a video4linux2 device, auto-adjust size.
- ffplay -f video4linux2 /dev/video0
+ # Grab and show the input of a video4linux2 device.
 -avplay -f video4linux2 -framerate 30 -video_size hd720 /dev/video0
++ffplay -f video4linux2 -framerate 30 -video_size hd720 /dev/video0
  
- # Grab and record the input of a video4linux2 device, auto-adjust size,
- # frame rate value defaults to 0/0 so it is read from the video4linux2
- # driver.
- ffmpeg -f video4linux2 -i /dev/video0 out.mpeg
+ # Grab and record the input of a video4linux2 device, leave the
+ framerate and size as previously set.
 -avconv -f video4linux2 -input_format mjpeg -i /dev/video0 out.mpeg
++ffmpeg -f video4linux2 -input_format mjpeg -i /dev/video0 out.mpeg
  @end example
  
 +"v4l" and "v4l2" can be used as aliases for the respective "video4linux" and
 +"video4linux2".
 +
  @section vfwcap
  
  VfW (Video for Windows) capture input device.
@@@ -100,9 -92,8 +100,9 @@@ OBJS-$(CONFIG_AYUV_ENCODER)            
  OBJS-$(CONFIG_BETHSOFTVID_DECODER)     += bethsoftvideo.o
  OBJS-$(CONFIG_BFI_DECODER)             += bfi.o
  OBJS-$(CONFIG_BINK_DECODER)            += bink.o binkdsp.o
- OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER)   += binkaudio.o wma.o
- OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER)  += binkaudio.o wma.o
+ OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER)   += binkaudio.o wma.o wma_common.o
+ OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER)  += binkaudio.o wma.o wma_common.o
 +OBJS-$(CONFIG_BINTEXT_DECODER)         += bintext.o cga_data.o
  OBJS-$(CONFIG_BMP_DECODER)             += bmp.o msrledec.o
  OBJS-$(CONFIG_BMP_ENCODER)             += bmpenc.o
  OBJS-$(CONFIG_BMV_VIDEO_DECODER)       += bmv.o
@@@ -105,20 -105,9 +105,20 @@@ int16_t ff_acelp_decode_gain_code
      for(i=0; i<ma_pred_order; i++)
          mr_energy += quant_energy[i] * ma_prediction_coeff[i];
  
 +#ifdef G729_BITEXACT
 +    mr_energy += (((-6165LL * ff_log2(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size, 0))) >> 3) & ~0x3ff);
 +
 +    mr_energy = (5439 * (mr_energy >> 15)) >> 8;           // (0.15) = (0.15) * (7.23)
 +
 +    return bidir_sal(
 +               ((ff_exp2(mr_energy & 0x7fff) + 16) >> 5) * (gain_corr_factor >> 1),
 +               (mr_energy >> 15) - 25
 +           );
 +#else
      mr_energy = gain_corr_factor * exp(M_LN10 / (20 << 23) * mr_energy) /
-                 sqrt(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size, 0));
+                 sqrt(dsp->scalarproduct_int16(fc_v, fc_v, subframe_size));
      return mr_energy >> 12;
 +#endif
  }
  
  float ff_amr_set_fixed_gain(float fixed_gain_factor, float fixed_mean_energy,
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -284,42 -283,33 +284,42 @@@ static const DVprofile dv_profiles[] = 
      }
  };
  
 -const DVprofile* avpriv_dv_frame_profile(const DVprofile *sys,
 +const DVprofile* avpriv_dv_frame_profile2(AVCodecContext* codec, const DVprofile *sys,
                                    const uint8_t* frame, unsigned buf_size)
  {
-    int i, dsf, stype;
+     int i, dsf, stype;
  
-    if(buf_size < DV_PROFILE_BYTES)
-        return NULL;
 -    if (buf_size < 80 * 5 + 48 + 4)
++    if(buf_size < DV_PROFILE_BYTES)
+         return NULL;
  
-    dsf = (frame[3] & 0x80) >> 7;
-    stype = frame[80*5 + 48 + 3] & 0x1f;
+     dsf = (frame[3] & 0x80) >> 7;
+     stype = frame[80 * 5 + 48 + 3] & 0x1f;
  
-    /* 576i50 25Mbps 4:1:1 is a special case */
-    if (dsf == 1 && stype == 0 && frame[4] & 0x07 /* the APT field */) {
-        return &dv_profiles[2];
-    }
+     /* 576i50 25Mbps 4:1:1 is a special case */
+     if (dsf == 1 && stype == 0 && frame[4] & 0x07 /* the APT field */) {
+         return &dv_profiles[2];
+     }
  
-    if(codec && codec->codec_tag==AV_RL32("dvsd") &&  codec->width==720 && codec->height==576)
-        return &dv_profiles[1];
++    if(codec && codec->codec_tag==AV_RL32("dvsd") &&  codec->width==720 && codec->height==576)
++        return &dv_profiles[1];
 +
-    for (i=0; i<FF_ARRAY_ELEMS(dv_profiles); i++)
-        if (dsf == dv_profiles[i].dsf && stype == dv_profiles[i].video_stype)
-            return &dv_profiles[i];
+     for (i = 0; i < FF_ARRAY_ELEMS(dv_profiles); i++)
+         if (dsf == dv_profiles[i].dsf && stype == dv_profiles[i].video_stype)
+             return &dv_profiles[i];
  
-    /* check if old sys matches and assumes corrupted input */
-    if (sys && buf_size == sys->frame_size)
-        return sys;
+     /* check if old sys matches and assumes corrupted input */
+     if (sys && buf_size == sys->frame_size)
+         return sys;
  
-    return NULL;
+     return NULL;
  }
  
 +const DVprofile* avpriv_dv_frame_profile(const DVprofile *sys,
 +                                  const uint8_t* frame, unsigned buf_size)
 +{
 +    return avpriv_dv_frame_profile2(NULL, sys, frame, buf_size);
 +}
 +
  const DVprofile* avpriv_dv_codec_profile(AVCodecContext* codec)
  {
      int i;
@@@ -195,15 -191,11 +191,11 @@@ static int tgq_decode_frame(AVCodecCont
                              AVPacket *avpkt){
      const uint8_t *buf = avpkt->data;
      int buf_size = avpkt->size;
-     const uint8_t *buf_start = buf;
-     const uint8_t *buf_end = buf + buf_size;
      TgqContext *s = avctx->priv_data;
 -    int x,y;
 +    int x,y, ret;
      int big_endian = AV_RL32(&buf[4]) > 0x000FFFFF;
-     buf += 8;
  
-     if(8>buf_end-buf) {
+     if (buf_size < 16) {
          av_log(avctx, AV_LOG_WARNING, "truncated header\n");
          return -1;
      }
index 87472f6,0000000..fc90374
mode 100644,000000..100644
--- /dev/null
@@@ -1,610 -1,0 +1,610 @@@
-                                     subframe_size, 0);
 +/*
 + * G.729, G729 Annex D postfilter
 + * Copyright (c) 2008 Vladimir Voroshilov
 + *
 + * 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 <inttypes.h>
 +#include <limits.h>
 +
 +#include "avcodec.h"
 +#include "g729.h"
 +#include "acelp_pitch_delay.h"
 +#include "g729postfilter.h"
 +#include "celp_math.h"
 +#include "acelp_filters.h"
 +#include "acelp_vectors.h"
 +#include "celp_filters.h"
 +
 +#define FRAC_BITS 15
 +#include "mathops.h"
 +
 +/**
 + * short interpolation filter (of length 33, according to spec)
 + * for computing signal with non-integer delay
 + */
 +static const int16_t ff_g729_interp_filt_short[(ANALYZED_FRAC_DELAYS+1)*SHORT_INT_FILT_LEN] = {
 +      0, 31650, 28469, 23705, 18050, 12266,  7041,  2873,
 +      0, -1597, -2147, -1992, -1492,  -933,  -484,  -188,
 +};
 +
 +/**
 + * long interpolation filter (of length 129, according to spec)
 + * for computing signal with non-integer delay
 + */
 +static const int16_t ff_g729_interp_filt_long[(ANALYZED_FRAC_DELAYS+1)*LONG_INT_FILT_LEN] = {
 +   0, 31915, 29436, 25569, 20676, 15206,  9639,  4439,
 +   0, -3390, -5579, -6549, -6414, -5392, -3773, -1874,
 +   0,  1595,  2727,  3303,  3319,  2850,  2030,  1023,
 +   0,  -887, -1527, -1860, -1876, -1614, -1150,  -579,
 +   0,   501,   859,  1041,  1044,   892,   631,   315,
 +   0,  -266,  -453,  -543,  -538,  -455,  -317,  -156,
 +   0,   130,   218,   258,   253,   212,   147,    72,
 +   0,   -59,  -101,  -122,  -123,  -106,   -77,   -40,
 +};
 +
 +/**
 + * formant_pp_factor_num_pow[i] = FORMANT_PP_FACTOR_NUM^(i+1)
 + */
 +static const int16_t formant_pp_factor_num_pow[10]= {
 +  /* (0.15) */
 +  18022, 9912, 5451, 2998, 1649, 907, 499, 274, 151, 83
 +};
 +
 +/**
 + * formant_pp_factor_den_pow[i] = FORMANT_PP_FACTOR_DEN^(i+1)
 + */
 +static const int16_t formant_pp_factor_den_pow[10] = {
 +  /* (0.15) */
 +  22938, 16057, 11240, 7868, 5508, 3856, 2699, 1889, 1322, 925
 +};
 +
 +/**
 + * \brief Residual signal calculation (4.2.1 if G.729)
 + * \param out [out] output data filtered through A(z/FORMANT_PP_FACTOR_NUM)
 + * \param filter_coeffs (3.12) A(z/FORMANT_PP_FACTOR_NUM) filter coefficients
 + * \param in input speech data to process
 + * \param subframe_size size of one subframe
 + *
 + * \note in buffer must contain 10 items of previous speech data before top of the buffer
 + * \remark It is safe to pass the same buffer for input and output.
 + */
 +static void residual_filter(int16_t* out, const int16_t* filter_coeffs, const int16_t* in,
 +                            int subframe_size)
 +{
 +    int i, n;
 +
 +    for (n = subframe_size - 1; n >= 0; n--) {
 +        int sum = 0x800;
 +        for (i = 0; i < 10; i++)
 +            sum += filter_coeffs[i] * in[n - i - 1];
 +
 +        out[n] = in[n] + (sum >> 12);
 +    }
 +}
 +
 +/**
 + * \brief long-term postfilter (4.2.1)
 + * \param dsp initialized DSP context
 + * \param pitch_delay_int integer part of the pitch delay in the first subframe
 + * \param residual filtering input data
 + * \param residual_filt [out] speech signal with applied A(z/FORMANT_PP_FACTOR_NUM) filter
 + * \param subframe_size size of subframe
 + *
 + * \return 0 if long-term prediction gain is less than 3dB, 1 -  otherwise
 + */
 +static int16_t long_term_filter(DSPContext *dsp, int pitch_delay_int,
 +                                const int16_t* residual, int16_t *residual_filt,
 +                                int subframe_size)
 +{
 +    int i, k, tmp, tmp2;
 +    int sum;
 +    int L_temp0;
 +    int L_temp1;
 +    int64_t L64_temp0;
 +    int64_t L64_temp1;
 +    int16_t shift;
 +    int corr_int_num, corr_int_den;
 +
 +    int ener;
 +    int16_t sh_ener;
 +
 +    int16_t gain_num,gain_den; //selected signal's gain numerator and denominator
 +    int16_t sh_gain_num, sh_gain_den;
 +    int gain_num_square;
 +
 +    int16_t gain_long_num,gain_long_den; //filtered through long interpolation filter signal's gain numerator and denominator
 +    int16_t sh_gain_long_num, sh_gain_long_den;
 +
 +    int16_t best_delay_int, best_delay_frac;
 +
 +    int16_t delayed_signal_offset;
 +    int lt_filt_factor_a, lt_filt_factor_b;
 +
 +    int16_t * selected_signal;
 +    const int16_t * selected_signal_const; //Necessary to avoid compiler warning
 +
 +    int16_t sig_scaled[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
 +    int16_t delayed_signal[ANALYZED_FRAC_DELAYS][SUBFRAME_SIZE+1];
 +    int corr_den[ANALYZED_FRAC_DELAYS][2];
 +
 +    tmp = 0;
 +    for(i=0; i<subframe_size + RES_PREV_DATA_SIZE; i++)
 +        tmp |= FFABS(residual[i]);
 +
 +    if(!tmp)
 +        shift = 3;
 +    else
 +        shift = av_log2(tmp) - 11;
 +
 +    if (shift > 0)
 +        for (i = 0; i < subframe_size + RES_PREV_DATA_SIZE; i++)
 +            sig_scaled[i] = residual[i] >> shift;
 +    else
 +        for (i = 0; i < subframe_size + RES_PREV_DATA_SIZE; i++)
 +            sig_scaled[i] = residual[i] << -shift;
 +
 +    /* Start of best delay searching code */
 +    gain_num = 0;
 +
 +    ener = dsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE,
 +                                    sig_scaled + RES_PREV_DATA_SIZE,
-                                            subframe_size, 0);
++                                    subframe_size);
 +    if (ener) {
 +        sh_ener = FFMAX(av_log2(ener) - 14, 0);
 +        ener >>= sh_ener;
 +        /* Search for best pitch delay.
 +
 +                       sum{ r(n) * r(k,n) ] }^2
 +           R'(k)^2 := -------------------------
 +                       sum{ r(k,n) * r(k,n) }
 +
 +
 +           R(T)    :=  sum{ r(n) * r(n-T) ] }
 +
 +
 +           where
 +           r(n-T) is integer delayed signal with delay T
 +           r(k,n) is non-integer delayed signal with integer delay best_delay
 +           and fractional delay k */
 +
 +        /* Find integer delay best_delay which maximizes correlation R(T).
 +
 +           This is also equals to numerator of R'(0),
 +           since the fine search (second step) is done with 1/8
 +           precision around best_delay. */
 +        corr_int_num = 0;
 +        best_delay_int = pitch_delay_int - 1;
 +        for (i = pitch_delay_int - 1; i <= pitch_delay_int + 1; i++) {
 +            sum = dsp->scalarproduct_int16(sig_scaled + RES_PREV_DATA_SIZE,
 +                                           sig_scaled + RES_PREV_DATA_SIZE - i,
-                                                     subframe_size, 0);
++                                           subframe_size);
 +            if (sum > corr_int_num) {
 +                corr_int_num = sum;
 +                best_delay_int = i;
 +            }
 +        }
 +        if (corr_int_num) {
 +            /* Compute denominator of pseudo-normalized correlation R'(0). */
 +            corr_int_den = dsp->scalarproduct_int16(sig_scaled - best_delay_int + RES_PREV_DATA_SIZE,
 +                                                    sig_scaled - best_delay_int + RES_PREV_DATA_SIZE,
-                                                subframe_size - 1, 0);
++                                                    subframe_size);
 +
 +            /* Compute signals with non-integer delay k (with 1/8 precision),
 +               where k is in [0;6] range.
 +               Entire delay is qual to best_delay+(k+1)/8
 +               This is archieved by applying an interpolation filter of
 +               legth 33 to source signal. */
 +            for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) {
 +                ff_acelp_interpolate(&delayed_signal[k][0],
 +                                     &sig_scaled[RES_PREV_DATA_SIZE - best_delay_int],
 +                                     ff_g729_interp_filt_short,
 +                                     ANALYZED_FRAC_DELAYS+1,
 +                                     8 - k - 1,
 +                                     SHORT_INT_FILT_LEN,
 +                                     subframe_size + 1);
 +            }
 +
 +            /* Compute denominator of pseudo-normalized correlation R'(k).
 +
 +                 corr_den[k][0] is square root of R'(k) denominator, for int(T) == int(T0)
 +                 corr_den[k][1] is square root of R'(k) denominator, for int(T) == int(T0)+1
 +
 +              Also compute maximum value of above denominators over all k. */
 +            tmp = corr_int_den;
 +            for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) {
 +                sum = dsp->scalarproduct_int16(&delayed_signal[k][1],
 +                                               &delayed_signal[k][1],
-                                                        subframe_size, 0);
++                                               subframe_size - 1);
 +                corr_den[k][0] = sum + delayed_signal[k][0            ] * delayed_signal[k][0            ];
 +                corr_den[k][1] = sum + delayed_signal[k][subframe_size] * delayed_signal[k][subframe_size];
 +
 +                tmp = FFMAX3(tmp, corr_den[k][0], corr_den[k][1]);
 +            }
 +
 +            sh_gain_den = av_log2(tmp) - 14;
 +            if (sh_gain_den >= 0) {
 +
 +                sh_gain_num =  FFMAX(sh_gain_den, sh_ener);
 +                /* Loop through all k and find delay that maximizes
 +                   R'(k) correlation.
 +                   Search is done in [int(T0)-1; intT(0)+1] range
 +                   with 1/8 precision. */
 +                delayed_signal_offset = 1;
 +                best_delay_frac = 0;
 +                gain_den = corr_int_den >> sh_gain_den;
 +                gain_num = corr_int_num >> sh_gain_num;
 +                gain_num_square = gain_num * gain_num;
 +                for (k = 0; k < ANALYZED_FRAC_DELAYS; k++) {
 +                    for (i = 0; i < 2; i++) {
 +                        int16_t gain_num_short, gain_den_short;
 +                        int gain_num_short_square;
 +                        /* Compute numerator of pseudo-normalized
 +                           correlation R'(k). */
 +                        sum = dsp->scalarproduct_int16(&delayed_signal[k][i],
 +                                                       sig_scaled + RES_PREV_DATA_SIZE,
-                                        subframe_size, 0);
++                                                       subframe_size);
 +                        gain_num_short = FFMAX(sum >> sh_gain_num, 0);
 +
 +                        /*
 +                                      gain_num_short_square                gain_num_square
 +                           R'(T)^2 = -----------------------, max R'(T)^2= --------------
 +                                           den                                 gain_den
 +                        */
 +                        gain_num_short_square = gain_num_short * gain_num_short;
 +                        gain_den_short = corr_den[k][i] >> sh_gain_den;
 +
 +                        tmp = MULL(gain_num_short_square, gain_den, FRAC_BITS);
 +                        tmp2 = MULL(gain_num_square, gain_den_short, FRAC_BITS);
 +
 +                        // R'(T)^2 > max R'(T)^2
 +                        if (tmp > tmp2) {
 +                            gain_num = gain_num_short;
 +                            gain_den = gain_den_short;
 +                            gain_num_square = gain_num_short_square;
 +                            delayed_signal_offset = i;
 +                            best_delay_frac = k + 1;
 +                        }
 +                    }
 +                }
 +
 +                /*
 +                       R'(T)^2
 +                  2 * --------- < 1
 +                        R(0)
 +                */
 +                L64_temp0 =  (int64_t)gain_num_square  << ((sh_gain_num << 1) + 1);
 +                L64_temp1 = ((int64_t)gain_den * ener) << (sh_gain_den + sh_ener);
 +                if (L64_temp0 < L64_temp1)
 +                    gain_num = 0;
 +            } // if(sh_gain_den >= 0)
 +        } // if(corr_int_num)
 +    } // if(ener)
 +    /* End of best delay searching code  */
 +
 +    if (!gain_num) {
 +        memcpy(residual_filt, residual + RES_PREV_DATA_SIZE, subframe_size * sizeof(int16_t));
 +
 +        /* Long-term prediction gain is less than 3dB. Long-term postfilter is disabled. */
 +        return 0;
 +    }
 +    if (best_delay_frac) {
 +        /* Recompute delayed signal with an interpolation filter of length 129. */
 +        ff_acelp_interpolate(residual_filt,
 +                             &sig_scaled[RES_PREV_DATA_SIZE - best_delay_int + delayed_signal_offset],
 +                             ff_g729_interp_filt_long,
 +                             ANALYZED_FRAC_DELAYS + 1,
 +                             8 - best_delay_frac,
 +                             LONG_INT_FILT_LEN,
 +                             subframe_size + 1);
 +        /* Compute R'(k) correlation's numerator. */
 +        sum = dsp->scalarproduct_int16(residual_filt,
 +                                       sig_scaled + RES_PREV_DATA_SIZE,
-         sum = dsp->scalarproduct_int16(residual_filt, residual_filt, subframe_size, 0);
++                                       subframe_size);
 +
 +        if (sum < 0) {
 +            gain_long_num = 0;
 +            sh_gain_long_num = 0;
 +        } else {
 +            tmp = FFMAX(av_log2(sum) - 14, 0);
 +            sum >>= tmp;
 +            gain_long_num = sum;
 +            sh_gain_long_num = tmp;
 +        }
 +
 +        /* Compute R'(k) correlation's denominator. */
-     rh0 = dsp->scalarproduct_int16(lp_gn + 10, lp_gn + 10, 20, 0);
-     rh1 = dsp->scalarproduct_int16(lp_gn + 10, lp_gn + 11, 20, 0);
++        sum = dsp->scalarproduct_int16(residual_filt, residual_filt, subframe_size);
 +
 +        tmp = FFMAX(av_log2(sum) - 14, 0);
 +        sum >>= tmp;
 +        gain_long_den = sum;
 +        sh_gain_long_den = tmp;
 +
 +        /* Select between original and delayed signal.
 +           Delayed signal will be selected if it increases R'(k)
 +           correlation. */
 +        L_temp0 = gain_num * gain_num;
 +        L_temp0 = MULL(L_temp0, gain_long_den, FRAC_BITS);
 +
 +        L_temp1 = gain_long_num * gain_long_num;
 +        L_temp1 = MULL(L_temp1, gain_den, FRAC_BITS);
 +
 +        tmp = ((sh_gain_long_num - sh_gain_num) << 1) - (sh_gain_long_den - sh_gain_den);
 +        if (tmp > 0)
 +            L_temp0 >>= tmp;
 +        else
 +            L_temp1 >>= -tmp;
 +
 +        /* Check if longer filter increases the values of R'(k). */
 +        if (L_temp1 > L_temp0) {
 +            /* Select long filter. */
 +            selected_signal = residual_filt;
 +            gain_num = gain_long_num;
 +            gain_den = gain_long_den;
 +            sh_gain_num = sh_gain_long_num;
 +            sh_gain_den = sh_gain_long_den;
 +        } else
 +            /* Select short filter. */
 +            selected_signal = &delayed_signal[best_delay_frac-1][delayed_signal_offset];
 +
 +        /* Rescale selected signal to original value. */
 +        if (shift > 0)
 +            for (i = 0; i < subframe_size; i++)
 +                selected_signal[i] <<= shift;
 +        else
 +            for (i = 0; i < subframe_size; i++)
 +                selected_signal[i] >>= -shift;
 +
 +        /* necessary to avoid compiler warning */
 +        selected_signal_const = selected_signal;
 +    } // if(best_delay_frac)
 +    else
 +        selected_signal_const = residual + RES_PREV_DATA_SIZE - (best_delay_int + 1 - delayed_signal_offset);
 +#ifdef G729_BITEXACT
 +    tmp = sh_gain_num - sh_gain_den;
 +    if (tmp > 0)
 +        gain_den >>= tmp;
 +    else
 +        gain_num >>= -tmp;
 +
 +    if (gain_num > gain_den)
 +        lt_filt_factor_a = MIN_LT_FILT_FACTOR_A;
 +    else {
 +        gain_num >>= 2;
 +        gain_den >>= 1;
 +        lt_filt_factor_a = (gain_den << 15) / (gain_den + gain_num);
 +    }
 +#else
 +    L64_temp0 = ((int64_t)gain_num) << (sh_gain_num - 1);
 +    L64_temp1 = ((int64_t)gain_den) << sh_gain_den;
 +    lt_filt_factor_a = FFMAX((L64_temp1 << 15) / (L64_temp1 + L64_temp0), MIN_LT_FILT_FACTOR_A);
 +#endif
 +
 +    /* Filter through selected filter. */
 +    lt_filt_factor_b = 32767 - lt_filt_factor_a + 1;
 +
 +    ff_acelp_weighted_vector_sum(residual_filt, residual + RES_PREV_DATA_SIZE,
 +                                 selected_signal_const,
 +                                 lt_filt_factor_a, lt_filt_factor_b,
 +                                 1<<14, 15, subframe_size);
 +
 +    // Long-term prediction gain is larger than 3dB.
 +    return 1;
 +}
 +
 +/**
 + * \brief Calculate reflection coefficient for tilt compensation filter (4.2.3).
 + * \param dsp initialized DSP context
 + * \param lp_gn (3.12) coefficients of A(z/FORMANT_PP_FACTOR_NUM) filter
 + * \param lp_gd (3.12) coefficients of A(z/FORMANT_PP_FACTOR_DEN) filter
 + * \param speech speech to update
 + * \param subframe_size size of subframe
 + *
 + * \return (3.12) reflection coefficient
 + *
 + * \remark The routine also calculates the gain term for the short-term
 + *         filter (gf) and multiplies the speech data by 1/gf.
 + *
 + * \note All members of lp_gn, except 10-19 must be equal to zero.
 + */
 +static int16_t get_tilt_comp(DSPContext *dsp, int16_t *lp_gn,
 +                             const int16_t *lp_gd, int16_t* speech,
 +                             int subframe_size)
 +{
 +    int rh1,rh0; // (3.12)
 +    int temp;
 +    int i;
 +    int gain_term;
 +
 +    lp_gn[10] = 4096; //1.0 in (3.12)
 +
 +    /* Apply 1/A(z/FORMANT_PP_FACTOR_DEN) filter to hf. */
 +    ff_celp_lp_synthesis_filter(lp_gn + 11, lp_gd + 1, lp_gn + 11, 22, 10, 0, 0, 0x800);
 +    /* Now lp_gn (starting with 10) contains impulse response
 +       of A(z/FORMANT_PP_FACTOR_NUM)/A(z/FORMANT_PP_FACTOR_DEN) filter. */
 +
++    rh0 = dsp->scalarproduct_int16(lp_gn + 10, lp_gn + 10, 20);
++    rh1 = dsp->scalarproduct_int16(lp_gn + 10, lp_gn + 11, 20);
 +
 +    /* downscale to avoid overflow */
 +    temp = av_log2(rh0) - 14;
 +    if (temp > 0) {
 +        rh0 >>= temp;
 +        rh1 >>= temp;
 +    }
 +
 +    if (FFABS(rh1) > rh0 || !rh0)
 +        return 0;
 +
 +    gain_term = 0;
 +    for (i = 0; i < 20; i++)
 +        gain_term += FFABS(lp_gn[i + 10]);
 +    gain_term >>= 2; // (3.12) -> (5.10)
 +
 +    if (gain_term > 0x400) { // 1.0 in (5.10)
 +        temp = 0x2000000 / gain_term; // 1.0/gain_term in (0.15)
 +        for (i = 0; i < subframe_size; i++)
 +            speech[i] = (speech[i] * temp + 0x4000) >> 15;
 +    }
 +
 +    return -(rh1 << 15) / rh0;
 +}
 +
 +/**
 + * \brief Apply tilt compensation filter (4.2.3).
 + * \param res_pst [in/out] residual signal (partially filtered)
 + * \param k1 (3.12) reflection coefficient
 + * \param subframe_size size of subframe
 + * \param ht_prev_data previous data for 4.2.3, equation 86
 + *
 + * \return new value for ht_prev_data
 +*/
 +static int16_t apply_tilt_comp(int16_t* out, int16_t* res_pst, int refl_coeff,
 +                               int subframe_size, int16_t ht_prev_data)
 +{
 +    int tmp, tmp2;
 +    int i;
 +    int gt, ga;
 +    int fact, sh_fact;
 +
 +    if (refl_coeff > 0) {
 +        gt = (refl_coeff * G729_TILT_FACTOR_PLUS + 0x4000) >> 15;
 +        fact = 0x4000; // 0.5 in (0.15)
 +        sh_fact = 15;
 +    } else {
 +        gt = (refl_coeff * G729_TILT_FACTOR_MINUS + 0x4000) >> 15;
 +        fact = 0x800; // 0.5 in (3.12)
 +        sh_fact = 12;
 +    }
 +    ga = (fact << 15) / av_clip_int16(32768 - FFABS(gt));
 +    gt >>= 1;
 +
 +    /* Apply tilt compensation filter to signal. */
 +    tmp = res_pst[subframe_size - 1];
 +
 +    for (i = subframe_size - 1; i >= 1; i--) {
 +        tmp2 = (res_pst[i] << 15) + ((gt * res_pst[i-1]) << 1);
 +        tmp2 = (tmp2 + 0x4000) >> 15;
 +
 +        tmp2 = (tmp2 * ga * 2 + fact) >> sh_fact;
 +        out[i] = tmp2;
 +    }
 +    tmp2 = (res_pst[0] << 15) + ((gt * ht_prev_data) << 1);
 +    tmp2 = (tmp2 + 0x4000) >> 15;
 +    tmp2 = (tmp2 * ga * 2 + fact) >> sh_fact;
 +    out[0] = tmp2;
 +
 +    return tmp;
 +}
 +
 +void ff_g729_postfilter(DSPContext *dsp, int16_t* ht_prev_data, int* voicing,
 +                     const int16_t *lp_filter_coeffs, int pitch_delay_int,
 +                     int16_t* residual, int16_t* res_filter_data,
 +                     int16_t* pos_filter_data, int16_t *speech, int subframe_size)
 +{
 +    int16_t residual_filt_buf[SUBFRAME_SIZE+11];
 +    int16_t lp_gn[33]; // (3.12)
 +    int16_t lp_gd[11]; // (3.12)
 +    int tilt_comp_coeff;
 +    int i;
 +
 +    /* Zero-filling is necessary for tilt-compensation filter. */
 +    memset(lp_gn, 0, 33 * sizeof(int16_t));
 +
 +    /* Calculate A(z/FORMANT_PP_FACTOR_NUM) filter coefficients. */
 +    for (i = 0; i < 10; i++)
 +        lp_gn[i + 11] = (lp_filter_coeffs[i + 1] * formant_pp_factor_num_pow[i] + 0x4000) >> 15;
 +
 +    /* Calculate A(z/FORMANT_PP_FACTOR_DEN) filter coefficients. */
 +    for (i = 0; i < 10; i++)
 +        lp_gd[i + 1] = (lp_filter_coeffs[i + 1] * formant_pp_factor_den_pow[i] + 0x4000) >> 15;
 +
 +    /* residual signal calculation (one-half of short-term postfilter) */
 +    memcpy(speech - 10, res_filter_data, 10 * sizeof(int16_t));
 +    residual_filter(residual + RES_PREV_DATA_SIZE, lp_gn + 11, speech, subframe_size);
 +    /* Save data to use it in the next subframe. */
 +    memcpy(res_filter_data, speech + subframe_size - 10, 10 * sizeof(int16_t));
 +
 +    /* long-term filter. If long-term prediction gain is larger than 3dB (returned value is
 +       nonzero) then declare current subframe as periodic. */
 +    *voicing = FFMAX(*voicing, long_term_filter(dsp, pitch_delay_int,
 +                                                residual, residual_filt_buf + 10,
 +                                                subframe_size));
 +
 +    /* shift residual for using in next subframe */
 +    memmove(residual, residual + subframe_size, RES_PREV_DATA_SIZE * sizeof(int16_t));
 +
 +    /* short-term filter tilt compensation */
 +    tilt_comp_coeff = get_tilt_comp(dsp, lp_gn, lp_gd, residual_filt_buf + 10, subframe_size);
 +
 +    /* Apply second half of short-term postfilter: 1/A(z/FORMANT_PP_FACTOR_DEN) */
 +    ff_celp_lp_synthesis_filter(pos_filter_data + 10, lp_gd + 1,
 +                                residual_filt_buf + 10,
 +                                subframe_size, 10, 0, 0, 0x800);
 +    memcpy(pos_filter_data, pos_filter_data + subframe_size, 10 * sizeof(int16_t));
 +
 +    *ht_prev_data = apply_tilt_comp(speech, pos_filter_data + 10, tilt_comp_coeff,
 +                                    subframe_size, *ht_prev_data);
 +}
 +
 +/**
 + * \brief Adaptive gain control (4.2.4)
 + * \param gain_before gain of speech before applying postfilters
 + * \param gain_after  gain of speech after applying postfilters
 + * \param speech [in/out] signal buffer
 + * \param subframe_size length of subframe
 + * \param gain_prev (3.12) previous value of gain coefficient
 + *
 + * \return (3.12) last value of gain coefficient
 + */
 +int16_t ff_g729_adaptive_gain_control(int gain_before, int gain_after, int16_t *speech,
 +                                   int subframe_size, int16_t gain_prev)
 +{
 +    int gain; // (3.12)
 +    int n;
 +    int exp_before, exp_after;
 +
 +    if(!gain_after && gain_before)
 +        return 0;
 +
 +    if (gain_before) {
 +
 +        exp_before  = 14 - av_log2(gain_before);
 +        gain_before = bidir_sal(gain_before, exp_before);
 +
 +        exp_after  = 14 - av_log2(gain_after);
 +        gain_after = bidir_sal(gain_after, exp_after);
 +
 +        if (gain_before < gain_after) {
 +            gain = (gain_before << 15) / gain_after;
 +            gain = bidir_sal(gain, exp_after - exp_before - 1);
 +        } else {
 +            gain = ((gain_before - gain_after) << 14) / gain_after + 0x4000;
 +            gain = bidir_sal(gain, exp_after - exp_before);
 +        }
 +        gain = (gain * G729_AGC_FAC1 + 0x4000) >> 15; // gain * (1-0.9875)
 +    } else
 +        gain = 0;
 +
 +    for (n = 0; n < subframe_size; n++) {
 +        // gain_prev = gain + 0.9875 * gain_prev
 +        gain_prev = (G729_AGC_FACTOR * gain_prev + 0x4000) >> 15;
 +        gain_prev = av_clip_int16(gain + gain_prev);
 +        speech[n] = av_clip_int16((speech[n] * gain_prev + 0x2000) >> 14);
 +    }
 +    return gain_prev;
 +}
@@@ -64,15 -65,17 +66,17 @@@ static av_cold int mm_decode_init(AVCod
      return 0;
  }
  
- static void mm_decode_pal(MmContext *s, const uint8_t *buf, const uint8_t *buf_end)
+ static int mm_decode_pal(MmContext *s)
  {
      int i;
-     buf += 4;
-     for (i=0; i<128 && buf+2<buf_end; i++) {
-         s->palette[i] = 0xFF << 24 | AV_RB24(buf);
+     bytestream2_skip(&s->gb, 4);
+     for (i = 0; i < 128; i++) {
 -        s->palette[i] = bytestream2_get_be24(&s->gb);
++        s->palette[i] = 0xFF << 24 | bytestream2_get_be24(&s->gb);
          s->palette[i+128] = s->palette[i]<<2;
-         buf += 3;
      }
+     return 0;
  }
  
  /**
Simple merge
Simple merge
@@@ -148,13 -128,10 +148,16 @@@ static int raw_decode(AVCodecContext *a
      frame->top_field_first = avctx->coded_frame->top_field_first;
      frame->reordered_opaque = avctx->reordered_opaque;
      frame->pkt_pts          = avctx->pkt->pts;
 +    frame->pkt_pos          = avctx->pkt->pos;
 +
 +    if(context->tff>=0){
 +        frame->interlaced_frame = 1;
 +        frame->top_field_first  = context->tff;
 +    }
  
+     if(buf_size < context->length - (avctx->pix_fmt==PIX_FMT_PAL8 ? 256*4 : 0))
+         return -1;
      //2bpp and 4bpp raw in avi and mov (yes this is ugly ...)
      if (context->buffer) {
          int i;
Simple merge
@@@ -38,16 -38,15 +38,15 @@@ static void roqvideo_decode_frame(RoqCo
      unsigned int chunk_id = 0, chunk_arg = 0;
      unsigned long chunk_size = 0;
      int i, j, k, nv1, nv2, vqflg = 0, vqflg_pos = -1;
-     int vqid, bpos, xpos, ypos, xp, yp, x, y, mx, my;
+     int vqid, xpos, ypos, xp, yp, x, y, mx, my;
      int frame_stats[2][4] = {{0},{0}};
      roq_qcell *qcell;
-     const unsigned char *buf = ri->buf;
-     const unsigned char *buf_end = ri->buf + ri->size;
+     int64_t chunk_start;
  
-     while (buf + 8 <= buf_end) {
-         chunk_id = bytestream_get_le16(&buf);
-         chunk_size = bytestream_get_le32(&buf);
-         chunk_arg = bytestream_get_le16(&buf);
 -    while (bytestream2_get_bytes_left(&ri->gb) > 0) {
++    while (bytestream2_get_bytes_left(&ri->gb) >= 8) {
+         chunk_id   = bytestream2_get_le16(&ri->gb);
+         chunk_size = bytestream2_get_le32(&ri->gb);
+         chunk_arg  = bytestream2_get_le16(&ri->gb);
  
          if(chunk_id == RoQ_QUAD_VQ)
              break;
          }
      }
  
-     bpos = xpos = ypos = 0;
-     if (chunk_size > buf_end - buf) {
+     chunk_start = bytestream2_tell(&ri->gb);
+     xpos = ypos = 0;
++
++    if (chunk_size > bytestream2_get_bytes_left(&ri->gb)) {
 +        av_log(ri->avctx, AV_LOG_ERROR, "Chunk does not fit in input buffer\n");
-         chunk_size = buf_end - buf;
++        chunk_size = bytestream2_get_bytes_left(&ri->gb);
 +    }
-     while(bpos < chunk_size) {
++
+     while (bytestream2_tell(&ri->gb) < chunk_start + chunk_size) {
          for (yp = ypos; yp < ypos + 16; yp += 8)
              for (xp = xpos; xp < xpos + 16; xp += 8) {
-                 if (bpos >= chunk_size) {
++                if (bytestream2_tell(&ri->gb) >= chunk_start + chunk_size) {
 +                    av_log(ri->avctx, AV_LOG_ERROR, "Input buffer too small\n");
 +                    return;
 +                }
                  if (vqflg_pos < 0) {
-                     vqflg = buf[bpos++]; vqflg |= (buf[bpos++] << 8);
+                     vqflg = bytestream2_get_le16(&ri->gb);
                      vqflg_pos = 7;
                  }
                  vqid = (vqflg >> (vqflg_pos * 2)) & 0x3;
                          if(k & 0x01) x += 4;
                          if(k & 0x02) y += 4;
  
-                         if (bpos >= chunk_size) {
++                        if (bytestream2_tell(&ri->gb) >= chunk_start + chunk_size) {
 +                            av_log(ri->avctx, AV_LOG_ERROR, "Input buffer too small\n");
 +                            return;
 +                        }
                          if (vqflg_pos < 0) {
-                             vqflg = buf[bpos++];
-                             vqflg |= (buf[bpos++] << 8);
+                             vqflg = bytestream2_get_le16(&ri->gb);
                              vqflg_pos = 7;
                          }
                          vqid = (vqflg >> (vqflg_pos * 2)) & 0x3;
Simple merge
@@@ -440,10 -430,9 +431,9 @@@ static int smc_decode_frame(AVCodecCont
      SmcContext *s = avctx->priv_data;
      const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
  
-     s->buf = buf;
-     s->size = buf_size;
+     bytestream2_init(&s->gb, buf, buf_size);
  
 -    s->frame.reference = 1;
 +    s->frame.reference = 3;
      s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE |
                              FF_BUFFER_HINTS_REUSABLE | FF_BUFFER_HINTS_READABLE;
      if (avctx->reget_buffer(avctx, &s->frame)) {
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -536,35 -531,31 +536,45 @@@ yuv2422_1_c_template(SwsContext *c, con
  
      if (uvalpha < 2048) {
          for (i = 0; i < (dstW >> 1); i++) {
 -            int Y1 = buf0[i * 2]     >> 7;
 -            int Y2 = buf0[i * 2 + 1] >> 7;
 -            int U  = ubuf0[i]        >> 7;
 -            int V  = vbuf0[i]        >> 7;
 +            int Y1 = (buf0[i * 2    ]+64) >> 7;
 +            int Y2 = (buf0[i * 2 + 1]+64) >> 7;
 +            int U  = (ubuf0[i]       +64) >> 7;
 +            int V  = (vbuf0[i]       +64) >> 7;
 +
 +            if ((Y1 | Y2 | U | V) & 0x100) {
 +                Y1 = av_clip_uint8(Y1);
 +                Y2 = av_clip_uint8(Y2);
 +                U  = av_clip_uint8(U);
 +                V  = av_clip_uint8(V);
 +            }
  
+             Y1 = av_clip_uint8(Y1);
+             Y2 = av_clip_uint8(Y2);
+             U  = av_clip_uint8(U);
+             V  = av_clip_uint8(V);
              output_pixels(i * 4, Y1, U, Y2, V);
          }
      } else {
          const int16_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
          for (i = 0; i < (dstW >> 1); i++) {
 -            int Y1 =  buf0[i * 2]          >> 7;
 -            int Y2 =  buf0[i * 2 + 1]      >> 7;
 -            int U  = (ubuf0[i] + ubuf1[i]) >> 8;
 -            int V  = (vbuf0[i] + vbuf1[i]) >> 8;
 +            int Y1 = (buf0[i * 2    ]    + 64) >> 7;
 +            int Y2 = (buf0[i * 2 + 1]    + 64) >> 7;
 +            int U  = (ubuf0[i] + ubuf1[i]+128) >> 8;
 +            int V  = (vbuf0[i] + vbuf1[i]+128) >> 8;
 +
 +            if ((Y1 | Y2 | U | V) & 0x100) {
 +                Y1 = av_clip_uint8(Y1);
 +                Y2 = av_clip_uint8(Y2);
 +                U  = av_clip_uint8(U);
 +                V  = av_clip_uint8(V);
 +            }
  
+             Y1 = av_clip_uint8(Y1);
+             Y2 = av_clip_uint8(Y2);
+             U  = av_clip_uint8(U);
+             V  = av_clip_uint8(V);
              output_pixels(i * 4, Y1, U, Y2, V);
          }
      }
@@@ -1004,10 -1001,15 +1014,15 @@@ yuv2rgb_2_c_template(SwsContext *c, con
          int U  = (ubuf0[i]        * uvalpha1 + ubuf1[i]        * uvalpha) >> 19;
          int V  = (vbuf0[i]        * uvalpha1 + vbuf1[i]        * uvalpha) >> 19;
          int A1, A2;
 -        const void *r =  c->table_rV[V],
 -                   *g = (c->table_gU[U] + c->table_gV[V]),
 -                   *b =  c->table_bU[U];
 +        const void *r =  c->table_rV[V + YUVRGB_TABLE_HEADROOM],
 +                   *g = (c->table_gU[U + YUVRGB_TABLE_HEADROOM] + c->table_gV[V + YUVRGB_TABLE_HEADROOM]),
 +                   *b =  c->table_bU[U + YUVRGB_TABLE_HEADROOM];
  
+         Y1 = av_clip_uint8(Y1);
+         Y2 = av_clip_uint8(Y2);
+         U  = av_clip_uint8(U);
+         V  = av_clip_uint8(V);
          if (hasAlpha) {
              A1 = (abuf0[i * 2    ] * yalpha1 + abuf1[i * 2    ] * yalpha) >> 19;
              A2 = (abuf0[i * 2 + 1] * yalpha1 + abuf1[i * 2 + 1] * yalpha) >> 19;
@@@ -1030,18 -1034,25 +1047,25 @@@ yuv2rgb_1_c_template(SwsContext *c, con
  
      if (uvalpha < 2048) {
          for (i = 0; i < (dstW >> 1); i++) {
 -            int Y1 = buf0[i * 2]     >> 7;
 -            int Y2 = buf0[i * 2 + 1] >> 7;
 -            int U  = ubuf0[i]        >> 7;
 -            int V  = vbuf0[i]        >> 7;
 +            int Y1 = (buf0[i * 2    ] + 64) >> 7;
 +            int Y2 = (buf0[i * 2 + 1] + 64) >> 7;
 +            int U  = (ubuf0[i]        + 64) >> 7;
 +            int V  = (vbuf0[i]        + 64) >> 7;
              int A1, A2;
 -            const void *r =  c->table_rV[V],
 -                       *g = (c->table_gU[U] + c->table_gV[V]),
 -                       *b =  c->table_bU[U];
 +            const void *r =  c->table_rV[V + YUVRGB_TABLE_HEADROOM],
 +                       *g = (c->table_gU[U + YUVRGB_TABLE_HEADROOM] + c->table_gV[V + YUVRGB_TABLE_HEADROOM]),
 +                       *b =  c->table_bU[U + YUVRGB_TABLE_HEADROOM];
  
+             Y1 = av_clip_uint8(Y1);
+             Y2 = av_clip_uint8(Y2);
+             U  = av_clip_uint8(U);
+             V  = av_clip_uint8(V);
              if (hasAlpha) {
 -                A1 = abuf0[i * 2    ] >> 7;
 -                A2 = abuf0[i * 2 + 1] >> 7;
 +                A1 = abuf0[i * 2    ] * 255 + 16384 >> 15;
 +                A2 = abuf0[i * 2 + 1] * 255 + 16384 >> 15;
+                 A1 = av_clip_uint8(A1);
+                 A2 = av_clip_uint8(A2);
              }
  
              yuv2rgb_write(dest, i, Y1, Y2, hasAlpha ? A1 : 0, hasAlpha ? A2 : 0,
      } else {
          const int16_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
          for (i = 0; i < (dstW >> 1); i++) {
 -            int Y1 =  buf0[i * 2]          >> 7;
 -            int Y2 =  buf0[i * 2 + 1]      >> 7;
 -            int U  = (ubuf0[i] + ubuf1[i]) >> 8;
 -            int V  = (vbuf0[i] + vbuf1[i]) >> 8;
 +            int Y1 = (buf0[i * 2    ]     +  64) >> 7;
 +            int Y2 = (buf0[i * 2 + 1]     +  64) >> 7;
 +            int U  = (ubuf0[i] + ubuf1[i] + 128) >> 8;
 +            int V  = (vbuf0[i] + vbuf1[i] + 128) >> 8;
              int A1, A2;
 -            const void *r =  c->table_rV[V],
 -                       *g = (c->table_gU[U] + c->table_gV[V]),
 -                       *b =  c->table_bU[U];
 +            const void *r =  c->table_rV[V + YUVRGB_TABLE_HEADROOM],
 +                       *g = (c->table_gU[U + YUVRGB_TABLE_HEADROOM] + c->table_gV[V + YUVRGB_TABLE_HEADROOM]),
 +                       *b =  c->table_bU[U + YUVRGB_TABLE_HEADROOM];
  
+             Y1 = av_clip_uint8(Y1);
+             Y2 = av_clip_uint8(Y2);
+             U  = av_clip_uint8(U);
+             V  = av_clip_uint8(V);
              if (hasAlpha) {
 -                A1 = abuf0[i * 2    ] >> 7;
 -                A2 = abuf0[i * 2 + 1] >> 7;
 +                A1 = (abuf0[i * 2    ] + 64) >> 7;
 +                A2 = (abuf0[i * 2 + 1] + 64) >> 7;
+                 A1 = av_clip_uint8(A1);
+                 A2 = av_clip_uint8(A2);
              }
  
              yuv2rgb_write(dest, i, Y1, Y2, hasAlpha ? A1 : 0, hasAlpha ? A2 : 0,