@@ -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

@@ -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"

@@ -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]);

@@ -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) {

@@ -56,14 +56,8 @@ typedef struct IpvideoContext {

     const unsigned char *decoding_map;

     int decoding_map_size;

-    const unsigned char *buf;

-    int size;

-

     int is_16bpp;

-    const unsigned char *stream_ptr;

-    const unsigned char *stream_end;

-    const uint8_t *mv_ptr;

-    const uint8_t *mv_end;

+    GetByteContext stream_ptr, mv_ptr;

     unsigned char *pixel_ptr;

     int line_inc;

     int stride;

@@ -72,13 +66,6 @@ typedef struct IpvideoContext {

     uint32_t pal[256];

 } IpvideoContext;

-#define CHECK_STREAM_PTR(stream_ptr, stream_end, n) \

-    if (stream_end - stream_ptr < n) { \

-        av_log(s->avctx, AV_LOG_ERROR, "stream_ptr out of bounds (%p >= %p)\n", \

-               stream_ptr + n, stream_end); \

-        return -1; \

-    }

-

 static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)

 {

     int current_offset = s->pixel_ptr - s->current_frame.data[0];

@@ -118,11 +105,9 @@ static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)

     /* copy block from 2 frames ago using a motion vector; need 1 more byte */

     if (!s->is_16bpp) {

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);

-        B = *s->stream_ptr++;

+        B = bytestream2_get_byte(&s->stream_ptr);

     } else {

-        CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);

-        B = *s->mv_ptr++;

+        B = bytestream2_get_byte(&s->mv_ptr);

     }

     if (B < 56) {

@@ -146,11 +131,9 @@ static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)

     /* need 1 more byte for motion */

     if (!s->is_16bpp) {

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);

-        B = *s->stream_ptr++;

+        B = bytestream2_get_byte(&s->stream_ptr);

     } else {

-        CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);

-        B = *s->mv_ptr++;

+        B = bytestream2_get_byte(&s->mv_ptr);

     }

     if (B < 56) {

@@ -172,11 +155,9 @@ static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)

     /* copy a block from the previous frame; need 1 more byte */

     if (!s->is_16bpp) {

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);

-        B = *s->stream_ptr++;

+        B = bytestream2_get_byte(&s->stream_ptr);

     } else {

-        CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);

-        B = *s->mv_ptr++;

+        B = bytestream2_get_byte(&s->mv_ptr);

     }

     BL = B & 0x0F;

@@ -194,10 +175,8 @@ static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)

     /* copy a block from the previous frame using an expanded range;

      * need 2 more bytes */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

-

-    x = *s->stream_ptr++;

-    y = *s->stream_ptr++;

+    x = bytestream2_get_byte(&s->stream_ptr);

+    y = bytestream2_get_byte(&s->stream_ptr);

     av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);

     return copy_from(s, &s->last_frame, x, y);

@@ -219,18 +198,14 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)

     unsigned int flags;

     /* 2-color encoding */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

-

-    P[0] = *s->stream_ptr++;

-    P[1] = *s->stream_ptr++;

+    P[0] = bytestream2_get_byte(&s->stream_ptr);

+    P[1] = bytestream2_get_byte(&s->stream_ptr);

     if (P[0] <= P[1]) {

         /* need 8 more bytes from the stream */

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

-

         for (y = 0; y < 8; y++) {

-            flags = *s->stream_ptr++ | 0x100;

+            flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;

             for (; flags != 1; flags >>= 1)

                 *s->pixel_ptr++ = P[flags & 1];

             s->pixel_ptr += s->line_inc;

@@ -239,9 +214,7 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)

     } else {

         /* need 2 more bytes from the stream */

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

-

-        flags = bytestream_get_le16(&s->stream_ptr);

+        flags = bytestream2_get_le16(&s->stream_ptr);

         for (y = 0; y < 8; y += 2) {

             for (x = 0; x < 8; x += 2, flags >>= 1) {

                 s->pixel_ptr[x                ] =

@@ -260,26 +233,23 @@ static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)

 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)

 {

     int x, y;

-    unsigned char P[2];

+    unsigned char P[4];

     unsigned int flags = 0;

     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on

      * either top and bottom or left and right halves */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

-

-    P[0] = *s->stream_ptr++;

-    P[1] = *s->stream_ptr++;

+    P[0] = bytestream2_get_byte(&s->stream_ptr);

+    P[1] = bytestream2_get_byte(&s->stream_ptr);

     if (P[0] <= P[1]) {

-

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 14);

-        s->stream_ptr -= 2;

-

         for (y = 0; y < 16; y++) {

             // new values for each 4x4 block

             if (!(y & 3)) {

-                P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;

-                flags = bytestream_get_le16(&s->stream_ptr);

+                if (y) {

+                    P[0]  = bytestream2_get_byte(&s->stream_ptr);

+                    P[1]  = bytestream2_get_byte(&s->stream_ptr);

+                }

+                flags = bytestream2_get_le16(&s->stream_ptr);

             }

             for (x = 0; x < 4; x++, flags >>= 1)

@@ -290,13 +260,11 @@ static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)

         }

     } else {

+        flags = bytestream2_get_le32(&s->stream_ptr);

+        P[2] = bytestream2_get_byte(&s->stream_ptr);

+        P[3] = bytestream2_get_byte(&s->stream_ptr);

-        /* need 10 more bytes */

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 10);

-

-        if (s->stream_ptr[4] <= s->stream_ptr[5]) {

-

-            flags = bytestream_get_le32(&s->stream_ptr);

+        if (P[2] <= P[3]) {

             /* vertical split; left & right halves are 2-color encoded */

@@ -307,8 +275,9 @@ static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)

                 // switch to right half

                 if (y == 7) {

                     s->pixel_ptr -= 8 * s->stride - 4;

-                    P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;

-                    flags = bytestream_get_le32(&s->stream_ptr);

+                    P[0]  = P[2];

+                    P[1]  = P[3];

+                    flags = bytestream2_get_le32(&s->stream_ptr);

                 }

             }

@@ -318,12 +287,12 @@ static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)

             for (y = 0; y < 8; y++) {

                 if (y == 4) {

-                    P[0] = *s->stream_ptr++;

-                    P[1] = *s->stream_ptr++;

+                    P[0]  = P[2];

+                    P[1]  = P[3];

+                    flags = bytestream2_get_le32(&s->stream_ptr);

                 }

-                flags = *s->stream_ptr++ | 0x100;

-                for (; flags != 1; flags >>= 1)

+                for (x = 0; x < 8; x++, flags >>= 1)

                     *s->pixel_ptr++ = P[flags & 1];

                 s->pixel_ptr += s->line_inc;

             }

@@ -340,20 +309,15 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)

     unsigned char P[4];

     /* 4-color encoding */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

-

-    memcpy(P, s->stream_ptr, 4);

-    s->stream_ptr += 4;

+    bytestream2_get_buffer(&s->stream_ptr, P, 4);

     if (P[0] <= P[1]) {

         if (P[2] <= P[3]) {

             /* 1 of 4 colors for each pixel, need 16 more bytes */

-            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);

-

             for (y = 0; y < 8; y++) {

                 /* get the next set of 8 2-bit flags */

-                int flags = bytestream_get_le16(&s->stream_ptr);

+                int flags = bytestream2_get_le16(&s->stream_ptr);

                 for (x = 0; x < 8; x++, flags >>= 2)

                     *s->pixel_ptr++ = P[flags & 0x03];

                 s->pixel_ptr += s->line_inc;

@@ -363,9 +327,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)

             uint32_t flags;

             /* 1 of 4 colors for each 2x2 block, need 4 more bytes */

-            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

-

-            flags = bytestream_get_le32(&s->stream_ptr);

+            flags = bytestream2_get_le32(&s->stream_ptr);

             for (y = 0; y < 8; y += 2) {

                 for (x = 0; x < 8; x += 2, flags >>= 2) {

@@ -382,9 +344,7 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)

         uint64_t flags;

         /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

-

-        flags = bytestream_get_le64(&s->stream_ptr);

+        flags = bytestream2_get_le64(&s->stream_ptr);

         if (P[2] <= P[3]) {

             for (y = 0; y < 8; y++) {

                 for (x = 0; x < 8; x += 2, flags >>= 2) {

@@ -411,24 +371,21 @@ static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)

 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)

 {

     int x, y;

-    unsigned char P[4];

+    unsigned char P[8];

     int flags = 0;

+    bytestream2_get_buffer(&s->stream_ptr, P, 4);

+

     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on

      * either top and bottom or left and right halves */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);

-

-    if (s->stream_ptr[0] <= s->stream_ptr[1]) {

+    if (P[0] <= P[1]) {

         /* 4-color encoding for each quadrant; need 32 bytes */

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);

-

         for (y = 0; y < 16; y++) {

             // new values for each 4x4 block

             if (!(y & 3)) {

-                memcpy(P, s->stream_ptr, 4);

-                s->stream_ptr += 4;

-                flags = bytestream_get_le32(&s->stream_ptr);

+                if (y) bytestream2_get_buffer(&s->stream_ptr, P, 4);

+                flags = bytestream2_get_le32(&s->stream_ptr);

             }

             for (x = 0; x < 4; x++, flags >>= 2)

@@ -441,20 +398,16 @@ static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)

     } else {

         // vertical split?

-        int vert = s->stream_ptr[12] <= s->stream_ptr[13];

-        uint64_t flags = 0;

+        int vert;

+        uint64_t flags = bytestream2_get_le64(&s->stream_ptr);

+

+        bytestream2_get_buffer(&s->stream_ptr, P + 4, 4);

+        vert = P[4] <= P[5];

         /* 4-color encoding for either left and right or top and bottom

          * halves */

         for (y = 0; y < 16; y++) {

-            // load values for each half

-            if (!(y & 7)) {

-                memcpy(P, s->stream_ptr, 4);

-                s->stream_ptr += 4;

-                flags = bytestream_get_le64(&s->stream_ptr);

-            }

-

             for (x = 0; x < 4; x++, flags >>= 2)

                 *s->pixel_ptr++ = P[flags & 0x03];

@@ -463,6 +416,12 @@ static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)

                 // switch to right half

                 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;

             } else if (y & 1) s->pixel_ptr += s->line_inc;

+

+            // load values for second half

+            if (y == 7) {

+                memcpy(P, P + 4, 4);

+                flags = bytestream2_get_le64(&s->stream_ptr);

+            }

         }

     }

@@ -475,11 +434,8 @@ static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)

     int y;

     /* 64-color encoding (each pixel in block is a different color) */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 64);

-

     for (y = 0; y < 8; y++) {

-        memcpy(s->pixel_ptr, s->stream_ptr, 8);

-        s->stream_ptr += 8;

+        bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);

         s->pixel_ptr  += s->stride;

     }

@@ -492,14 +448,12 @@ static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)

     int x, y;

     /* 16-color block encoding: each 2x2 block is a different color */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);

-

     for (y = 0; y < 8; y += 2) {

         for (x = 0; x < 8; x += 2) {

             s->pixel_ptr[x                ] =

             s->pixel_ptr[x + 1            ] =

             s->pixel_ptr[x +     s->stride] =

-            s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;

+            s->pixel_ptr[x + 1 + s->stride] = bytestream2_get_byte(&s->stream_ptr);

         }

         s->pixel_ptr += s->stride * 2;

     }

@@ -514,12 +468,10 @@ static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)

     unsigned char P[2];

     /* 4-color block encoding: each 4x4 block is a different color */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

-

     for (y = 0; y < 8; y++) {

         if (!(y & 3)) {

-            P[0] = *s->stream_ptr++;

-            P[1] = *s->stream_ptr++;

+            P[0] = bytestream2_get_byte(&s->stream_ptr);

+            P[1] = bytestream2_get_byte(&s->stream_ptr);

         }

         memset(s->pixel_ptr,     P[0], 4);

         memset(s->pixel_ptr + 4, P[1], 4);

@@ -536,8 +488,7 @@ static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)

     unsigned char pix;

     /* 1-color encoding: the whole block is 1 solid color */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);

-    pix = *s->stream_ptr++;

+    pix = bytestream2_get_byte(&s->stream_ptr);

     for (y = 0; y < 8; y++) {

         memset(s->pixel_ptr, pix, 8);

@@ -554,9 +505,8 @@ static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)

     unsigned char sample[2];

     /* dithered encoding */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

-    sample[0] = *s->stream_ptr++;

-    sample[1] = *s->stream_ptr++;

+    sample[0] = bytestream2_get_byte(&s->stream_ptr);

+    sample[1] = bytestream2_get_byte(&s->stream_ptr);

     for (y = 0; y < 8; y++) {

         for (x = 0; x < 8; x += 2) {

@@ -575,10 +525,8 @@ static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s)

     signed char x, y;

     /* copy a block from the second last frame using an expanded range */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

-

-    x = *s->stream_ptr++;

-    y = *s->stream_ptr++;

+    x = bytestream2_get_byte(&s->stream_ptr);

+    y = bytestream2_get_byte(&s->stream_ptr);

     av_dlog(s->avctx, "motion bytes = %d, %d\n", x, y);

     return copy_from(s, &s->second_last_frame, x, y);

@@ -592,17 +540,13 @@ static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)

     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

     /* 2-color encoding */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

-

-    P[0] = bytestream_get_le16(&s->stream_ptr);

-    P[1] = bytestream_get_le16(&s->stream_ptr);

+    P[0] = bytestream2_get_le16(&s->stream_ptr);

+    P[1] = bytestream2_get_le16(&s->stream_ptr);

     if (!(P[0] & 0x8000)) {

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

-

         for (y = 0; y < 8; y++) {

-            flags = *s->stream_ptr++ | 0x100;

+            flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;

             for (; flags != 1; flags >>= 1)

                 *pixel_ptr++ = P[flags & 1];

             pixel_ptr += s->line_inc;

@@ -610,9 +554,7 @@ static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)

     } else {

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

-

-        flags = bytestream_get_le16(&s->stream_ptr);

+        flags = bytestream2_get_le16(&s->stream_ptr);

         for (y = 0; y < 8; y += 2) {

             for (x = 0; x < 8; x += 2, flags >>= 1) {

                 pixel_ptr[x                ] =

@@ -630,28 +572,25 @@ static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)

 static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)

 {

     int x, y;

-    uint16_t P[2];

+    uint16_t P[4];

     unsigned int flags = 0;

     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on

      * either top and bottom or left and right halves */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

-

-    P[0] = bytestream_get_le16(&s->stream_ptr);

-    P[1] = bytestream_get_le16(&s->stream_ptr);

+    P[0] = bytestream2_get_le16(&s->stream_ptr);

+    P[1] = bytestream2_get_le16(&s->stream_ptr);

     if (!(P[0] & 0x8000)) {

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);

-        s->stream_ptr -= 4;

-

         for (y = 0; y < 16; y++) {

             // new values for each 4x4 block

             if (!(y & 3)) {

-                P[0] = bytestream_get_le16(&s->stream_ptr);

-                P[1] = bytestream_get_le16(&s->stream_ptr);

-                flags = bytestream_get_le16(&s->stream_ptr);

+                if (y) {

+                    P[0] = bytestream2_get_le16(&s->stream_ptr);

+                    P[1] = bytestream2_get_le16(&s->stream_ptr);

+                }

+                flags = bytestream2_get_le16(&s->stream_ptr);

             }

             for (x = 0; x < 4; x++, flags >>= 1)

@@ -663,11 +602,11 @@ static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)

     } else {

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 12);

-

-        if (!(AV_RL16(s->stream_ptr + 4) & 0x8000)) {

+        flags = bytestream2_get_le32(&s->stream_ptr);

+        P[2]  = bytestream2_get_le16(&s->stream_ptr);

+        P[3]  = bytestream2_get_le16(&s->stream_ptr);

-            flags = bytestream_get_le32(&s->stream_ptr);

+        if (!(P[2] & 0x8000)) {

             /* vertical split; left & right halves are 2-color encoded */

@@ -678,9 +617,9 @@ static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)

                 // switch to right half

                 if (y == 7) {

                     pixel_ptr -= 8 * s->stride - 4;

-                    P[0] = bytestream_get_le16(&s->stream_ptr);

-                    P[1] = bytestream_get_le16(&s->stream_ptr);

-                    flags = bytestream_get_le32(&s->stream_ptr);

+                    P[0]  = P[2];

+                    P[1]  = P[3];

+                    flags = bytestream2_get_le32(&s->stream_ptr);

                 }

             }

@@ -690,12 +629,12 @@ static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)

             for (y = 0; y < 8; y++) {

                 if (y == 4) {

-                    P[0] = bytestream_get_le16(&s->stream_ptr);

-                    P[1] = bytestream_get_le16(&s->stream_ptr);

+                    P[0]  = P[2];

+                    P[1]  = P[3];

+                    flags = bytestream2_get_le32(&s->stream_ptr);

                 }

-                flags = *s->stream_ptr++ | 0x100;

-                for (; flags != 1; flags >>= 1)

+                for (x = 0; x < 8; x++, flags >>= 1)

                     *pixel_ptr++ = P[flags & 1];

                 pixel_ptr += s->line_inc;

             }

@@ -713,20 +652,16 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)

     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

     /* 4-color encoding */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

-

     for (x = 0; x < 4; x++)

-        P[x] = bytestream_get_le16(&s->stream_ptr);

+        P[x] = bytestream2_get_le16(&s->stream_ptr);

     if (!(P[0] & 0x8000)) {

         if (!(P[2] & 0x8000)) {

             /* 1 of 4 colors for each pixel */

-            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);

-

             for (y = 0; y < 8; y++) {

                 /* get the next set of 8 2-bit flags */

-                int flags = bytestream_get_le16(&s->stream_ptr);

+                int flags = bytestream2_get_le16(&s->stream_ptr);

                 for (x = 0; x < 8; x++, flags >>= 2)

                     *pixel_ptr++ = P[flags & 0x03];

                 pixel_ptr += s->line_inc;

@@ -736,9 +671,7 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)

             uint32_t flags;

             /* 1 of 4 colors for each 2x2 block */

-            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

-

-            flags = bytestream_get_le32(&s->stream_ptr);

+            flags = bytestream2_get_le32(&s->stream_ptr);

             for (y = 0; y < 8; y += 2) {

                 for (x = 0; x < 8; x += 2, flags >>= 2) {

@@ -755,9 +688,7 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)

         uint64_t flags;

         /* 1 of 4 colors for each 2x1 or 1x2 block */

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

-

-        flags = bytestream_get_le64(&s->stream_ptr);

+        flags = bytestream2_get_le64(&s->stream_ptr);

         if (!(P[2] & 0x8000)) {

             for (y = 0; y < 8; y++) {

                 for (x = 0; x < 8; x += 2, flags >>= 2) {

@@ -784,25 +715,25 @@ static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)

 static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)

 {

     int x, y;

-    uint16_t P[4];

+    uint16_t P[8];

     int flags = 0;

     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

+    for (x = 0; x < 4; x++)

+        P[x] = bytestream2_get_le16(&s->stream_ptr);

+

     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on

      * either top and bottom or left and right halves */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);

-

-    if (!(AV_RL16(s->stream_ptr) & 0x8000)) {

+    if (!(P[0] & 0x8000)) {

         /* 4-color encoding for each quadrant */

-        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 48);

-

         for (y = 0; y < 16; y++) {

             // new values for each 4x4 block

             if (!(y & 3)) {

-                for (x = 0; x < 4; x++)

-                    P[x] = bytestream_get_le16(&s->stream_ptr);

-                flags = bytestream_get_le32(&s->stream_ptr);

+                if (y)

+                    for (x = 0; x < 4; x++)

+                        P[x] = bytestream2_get_le16(&s->stream_ptr);

+                flags = bytestream2_get_le32(&s->stream_ptr);

             }

             for (x = 0; x < 4; x++, flags >>= 2)

@@ -815,20 +746,17 @@ static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)

     } else {

         // vertical split?

-        int vert = !(AV_RL16(s->stream_ptr + 16) & 0x8000);

-        uint64_t flags = 0;

+        int vert;

+        uint64_t flags = bytestream2_get_le64(&s->stream_ptr);

+

+        for (x = 4; x < 8; x++)

+            P[x] = bytestream2_get_le16(&s->stream_ptr);

+        vert = !(P[4] & 0x8000);

         /* 4-color encoding for either left and right or top and bottom

          * halves */

         for (y = 0; y < 16; y++) {

-            // load values for each half

-            if (!(y & 7)) {

-                for (x = 0; x < 4; x++)

-                    P[x] = bytestream_get_le16(&s->stream_ptr);

-                flags = bytestream_get_le64(&s->stream_ptr);

-            }

-

             for (x = 0; x < 4; x++, flags >>= 2)

                 *pixel_ptr++ = P[flags & 0x03];

@@ -837,6 +765,12 @@ static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)

                 // switch to right half

                 if (y == 7) pixel_ptr -= 8 * s->stride - 4;

             } else if (y & 1) pixel_ptr += s->line_inc;

+

+            // load values for second half

+            if (y == 7) {

+                memcpy(P, P + 4, 8);

+                flags = bytestream2_get_le64(&s->stream_ptr);

+            }

         }

     }

@@ -850,11 +784,9 @@ static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s)

     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

     /* 64-color encoding (each pixel in block is a different color) */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 128);

-

     for (y = 0; y < 8; y++) {

         for (x = 0; x < 8; x++)

-            pixel_ptr[x] = bytestream_get_le16(&s->stream_ptr);

+            pixel_ptr[x] = bytestream2_get_le16(&s->stream_ptr);

         pixel_ptr  += s->stride;

     }

@@ -868,14 +800,12 @@ static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s)

     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

     /* 16-color block encoding: each 2x2 block is a different color */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);

-

     for (y = 0; y < 8; y += 2) {

         for (x = 0; x < 8; x += 2) {

             pixel_ptr[x                ] =

             pixel_ptr[x + 1            ] =

             pixel_ptr[x +     s->stride] =

-            pixel_ptr[x + 1 + s->stride] = bytestream_get_le16(&s->stream_ptr);

+            pixel_ptr[x + 1 + s->stride] = bytestream2_get_le16(&s->stream_ptr);

         }

         pixel_ptr += s->stride * 2;

     }

@@ -891,12 +821,10 @@ static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s)

     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

     /* 4-color block encoding: each 4x4 block is a different color */

-    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

-

     for (y = 0; y < 8; y++) {

         if (!(y & 3)) {

-            P[0] = bytestream_get_le16(&s->stream_ptr);

-            P[1] = bytestream_get_le16(&s->stream_ptr);

+            P[0] = bytestream2_get_le16(&s->stream_ptr);

+            P[1] = bytestream2_get_le16(&s->stream_ptr);

         }

         for (x = 0; x < 8; x++)

             pixel_ptr[x] = P[x >> 2];

@@ -914,8 +842,7 @@ static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s)