Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 3 Nov 2011 01:01:37 +0000 (02:01 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 3 Nov 2011 01:16:26 +0000 (02:16 +0100)
* qatar/master: (44 commits)
  replacement Indeo 3 decoder
  gsm demuxer: do not allocate packet twice.
  flvenc: use first packet delay as global delay.
  ac3enc: doxygen update.
  imc: return error codes instead of 0 for error conditions.
  imc: return meaningful error codes instead of -1
  imc: do not set channel layout for stereo
  imc: validate channel count
  imc: check for ff_fft_init() failure
  imc: check output buffer size before decoding
  imc: use DSPContext.bswap16_buf() to byte-swap packet data
  rtsp: add allowed_media_types option
  libgsm: add flush function to reset the decoder state when seeking
  libgsm: simplify decoding by using a loop
  gsm: log error message when packet is too small
  libgsmdec: do not needlessly set *data_size to 0
  gsmdec: do not needlessly set *data_size to 0
  gsmdec: add flush function to reset the decoder state when seeking
  libgsmdec: check output buffer size before decoding
  gsmdec: log error message when output buffer is too small.
  ...

Conflicts:
Changelog
ffplay.c
libavcodec/indeo3.c
libavcodec/mjpeg_parser.c
libavcodec/vp3.c
libavformat/cutils.c
libavformat/id3v2.c
libavutil/parseutils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
73 files changed:
1  2 
Changelog
libavcodec/aac_parser.c
libavcodec/ac3_parser.c
libavcodec/ac3enc.c
libavcodec/ac3enc_fixed.c
libavcodec/ac3enc_float.c
libavcodec/ac3enc_template.c
libavcodec/cavs_parser.c
libavcodec/dca_parser.c
libavcodec/dirac_parser.c
libavcodec/dnxhd_parser.c
libavcodec/dvbsub.c
libavcodec/dvbsub_parser.c
libavcodec/dvbsubdec.c
libavcodec/dvdsub_parser.c
libavcodec/dvdsubdec.c
libavcodec/dvdsubenc.c
libavcodec/flac_parser.c
libavcodec/g726.c
libavcodec/gsmdec.c
libavcodec/h261_parser.c
libavcodec/h263.c
libavcodec/h263_parser.c
libavcodec/h264_parser.c
libavcodec/idcinvideo.c
libavcodec/imc.c
libavcodec/indeo3.c
libavcodec/indeo3data.h
libavcodec/latm_parser.c
libavcodec/libgsm.c
libavcodec/libtheoraenc.c
libavcodec/mace.c
libavcodec/mjpeg_parser.c
libavcodec/mlp_parser.c
libavcodec/mpeg4video_parser.c
libavcodec/mpeg4videodec.c
libavcodec/mpegaudio_parser.c
libavcodec/mpegvideo_parser.c
libavcodec/msmpeg4.c
libavcodec/msmpeg4.h
libavcodec/msmpeg4data.c
libavcodec/msmpeg4data.h
libavcodec/pnm_parser.c
libavcodec/rpza.c
libavcodec/sparc/dsputil_vis.c
libavcodec/truemotion1data.h
libavcodec/vc1_parser.c
libavcodec/vp3.c
libavcodec/vp3_parser.c
libavcodec/vp8_parser.c
libavfilter/vf_drawtext.c
libavfilter/vsrc_testsrc.c
libavformat/Makefile
libavformat/asfdec.c
libavformat/au.c
libavformat/avio.c
libavformat/aviobuf.c
libavformat/avisynth.c
libavformat/cutils.c
libavformat/dv.c
libavformat/file.c
libavformat/flvenc.c
libavformat/id3v2.c
libavformat/mpegts.c
libavformat/os_support.c
libavformat/os_support.h
libavformat/rawdec.c
libavformat/riff.c
libavformat/rso.h
libavformat/rtsp.c
libavformat/rtsp.h
libavutil/log.c
libavutil/parseutils.c

diff --cc Changelog
+++ b/Changelog
@@@ -69,13 -56,35 +69,14 @@@ easier to use. The changes are
  - Speex encoding via libspeex
  - 4:2:2 H.264 decoding support
  - Pulseaudio input device
 +- Prores encoder
 +- Video Decoder Acceleration (VDA) HWAccel module.
+ - replacement Indeo 3 decoder
  
 +version 0.8:
  
 -version 0.7:
 -
 -- E-AC-3 audio encoder
 -- ac3enc: add channel coupling support
 -- floating-point sample format support for (E-)AC-3, DCA, AAC, Vorbis decoders
 -- H.264/MPEG frame-level multithreading
 -- av_metadata_* functions renamed to av_dict_* and moved to libavutil
 -- 4:4:4 H.264 decoding support
 -- 10-bit H.264 optimizations for x86
 -- bump libswscale for recently reported ABI break
 -
 -
 -version 0.7_beta2:
 -
 -- VP8 frame-level multithreading
 -- NEON optimizations for VP8
 -- removed a lot of deprecated API cruft
 -- FFT and IMDCT optimizations for AVX (Sandy Bridge) processors
 -- DPX image encoder
 -- SMPTE 302M AES3 audio decoder
 -- ffmpeg no longer quits after the 'q' key is pressed; use 'ctrl+c' instead
 -- 9bit and 10bit per sample support in the H.264 decoder
 -
 -
 -version 0.7_beta1:
  
 +- many many things we forgot because we rather write code than changelogs
  - WebM support in Matroska de/muxer
  - low overhead Ogg muxing
  - MMS-TCP support
Simple merge
Simple merge
Simple merge
@@@ -103,14 -105,8 +105,14 @@@ static void scale_coefficients(AC3Encod
      }
  }
  
 +static void sum_square_butterfly(AC3EncodeContext *s, int64_t sum[4],
 +                                 const int32_t *coef0, const int32_t *coef1,
 +                                 int len)
 +{
 +    s->ac3dsp.sum_square_butterfly_int32(sum, coef0, coef1, len);
 +}
  
- /**
+ /*
   * Clip MDCT coefficients to allowable range.
   */
  static void clip_coefficients(DSPContext *dsp, int32_t *coef, unsigned int len)
@@@ -110,14 -114,8 +114,14 @@@ static void scale_coefficients(AC3Encod
                                 chan_size * (s->channels + cpl));
  }
  
 +static void sum_square_butterfly(AC3EncodeContext *s, float sum[4],
 +                                 const float *coef0, const float *coef1,
 +                                 int len)
 +{
 +    s->ac3dsp.sum_square_butterfly_float(sum, coef0, coef1, len);
 +}
  
- /**
+ /*
   * Clip MDCT coefficients to allowable range.
   */
  static void clip_coefficients(DSPContext *dsp, float *coef, unsigned int len)
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * DVB subtitle encoding for ffmpeg
+  * DVB subtitle encoding
   * Copyright (c) 2005 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
Simple merge
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * DVB subtitle decoding for ffmpeg
+  * DVB subtitle decoding
   * Copyright (c) 2005 Ian Caulfield
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * DVD subtitle decoding for ffmpeg
+  * DVD subtitle decoding
   * Copyright (c) 2005 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * DVD subtitle decoding for ffmpeg
+  * DVD subtitle decoding
   * Copyright (c) 2005 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * DVD subtitle encoding for ffmpeg
+  * DVD subtitle encoding
   * Copyright (c) 2005 Wolfram Gloger
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -1,7 -1,10 +1,10 @@@
  /*
 - * This file is part of Libav.
+  * Indeo Video v3 compatible decoder
+  * Copyright (c) 2009 - 2011 Maxim Poliakovski
+  *
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -143,993 -198,845 +198,846 @@@ static av_cold int allocate_frame_buffe
      return 0;
  }
  
- static av_cold void iv_free_func(Indeo3DecodeContext *s)
+ static av_cold void free_frame_buffers(Indeo3DecodeContext *ctx)
  {
-     av_freep(&s->buf);
-     av_freep(&s->ModPred);
-     av_freep(&s->corrector_type);
+     int p;
+     for (p = 0; p < 3; p++) {
+         av_freep(&ctx->planes[p].buffers[0]);
+         av_freep(&ctx->planes[p].buffers[1]);
+     }
  }
  
- struct ustr {
-     int xpos;
-     int ypos;
-     int width;
-     int height;
-     int split_flag;
-     int split_direction;
-     int usl7;
- };
  
+ /**
+  *  Copy pixels of the cell(x + mv_x, y + mv_y) from the previous frame into
+  *  the cell(x, y) in the current frame.
+  *
+  *  @param ctx      pointer to the decoder context
+  *  @param plane    pointer to the plane descriptor
+  *  @param cell     pointer to the cell  descriptor
+  */
+ static void copy_cell(Indeo3DecodeContext *ctx, Plane *plane, Cell *cell)
+ {
+     int     h, w, mv_x, mv_y, offset, offset_dst;
+     uint8_t *src, *dst;
+     /* setup output and reference pointers */
+     offset_dst  = (cell->ypos << 2) * plane->pitch + (cell->xpos << 2);
+     dst         = plane->pixels[ctx->buf_sel] + offset_dst;
+     mv_y        = cell->mv_ptr[0];
+     mv_x        = cell->mv_ptr[1];
+     offset      = offset_dst + mv_y * plane->pitch + mv_x;
+     src         = plane->pixels[ctx->buf_sel ^ 1] + offset;
+     h = cell->height << 2;
+     for (w = cell->width; w > 0;) {
+         /* copy using 16xH blocks */
+         if (!((cell->xpos << 2) & 15) && w >= 4) {
+             for (; w >= 4; src += 16, dst += 16, w -= 4)
+                 ctx->dsp.put_no_rnd_pixels_tab[0][0](dst, src, plane->pitch, h);
+         }
  
- #define LV1_CHECK(buf1,rle_v3,lv1,lp2)  \
-     if((lv1 & 0x80) != 0) {             \
-         if(rle_v3 != 0)                 \
-             rle_v3 = 0;                 \
-         else {                          \
-             rle_v3 = 1;                 \
-             buf1 -= 2;                  \
-         }                               \
-     }                                   \
-     lp2 = 4;
- #define RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)  \
-     if(rle_v3 == 0) {                            \
-         rle_v2 = *buf1;                          \
-         rle_v1 = 1;                              \
-         if(rle_v2 > 32) {                        \
-             rle_v2 -= 32;                        \
-             rle_v1 = 0;                          \
-         }                                        \
-         rle_v3 = 1;                              \
-     }                                            \
-     buf1--;
- #define LP2_CHECK(buf1,rle_v3,lp2)  \
-     if(lp2 == 0 && rle_v3 != 0)     \
-         rle_v3 = 0;                 \
-     else {                          \
-         buf1--;                     \
-         rle_v3 = 1;                 \
+         /* copy using 8xH blocks */
+         if (!((cell->xpos << 2) & 7) && w >= 2) {
+             ctx->dsp.put_no_rnd_pixels_tab[1][0](dst, src, plane->pitch, h);
+             w -= 2;
+             src += 8;
+             dst += 8;
+         }
+         if (w >= 1) {
+             copy_block4(dst, src, plane->pitch, plane->pitch, h);
+             w--;
+             src += 4;
+             dst += 4;
+         }
      }
+ }
  
  
- #define RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2) \
-     rle_v2--;                                 \
-     if(rle_v2 == 0) {                         \
-         rle_v3 = 0;                           \
-         buf1 += 2;                            \
-     }                                         \
-     lp2 = 4;
+ /* Average 4/8 pixels at once without rounding using SWAR */
+ #define AVG_32(dst, src, ref) \
+     AV_WN32A(dst, ((AV_RN32A(src) + AV_RN32A(ref)) >> 1) & 0x7F7F7F7FUL)
  
- static void iv_Decode_Chunk(Indeo3DecodeContext *s,
-         uint8_t *cur, uint8_t *ref, int width, int height,
-         const uint8_t *buf1, int cb_offset, const uint8_t *hdr,
-         const uint8_t *buf2, int min_width_160)
- {
-     uint8_t bit_buf;
-     unsigned int bit_pos, lv, lv1, lv2;
-     int *width_tbl, width_tbl_arr[10];
-     const signed char *ref_vectors;
-     uint8_t *cur_frm_pos, *ref_frm_pos, *cp, *cp2;
-     uint8_t *cur_end = cur + width*height + width;
-     uint32_t *cur_lp, *ref_lp;
-     const uint32_t *correction_lp[2], *correctionloworder_lp[2], *correctionhighorder_lp[2];
-     uint8_t *correction_type_sp[2];
-     struct ustr strip_tbl[20], *strip;
-     int i, j, k, lp1, lp2, flag1, cmd, blks_width, blks_height, region_160_width,
-         rle_v1, rle_v2, rle_v3;
-     unsigned short res;
-     bit_buf = 0;
-     ref_vectors = NULL;
-     width_tbl = width_tbl_arr + 1;
-     i = (width < 0 ? width + 3 : width)/4;
-     for(j = -1; j < 8; j++)
-         width_tbl[j] = i * j;
-     strip = strip_tbl;
-     for(region_160_width = 0; region_160_width < (width - min_width_160); region_160_width += min_width_160);
-     strip->ypos = strip->xpos = 0;
-     for(strip->width = min_width_160; width > strip->width; strip->width *= 2);
-     strip->height = height;
-     strip->split_direction = 0;
-     strip->split_flag = 0;
-     strip->usl7 = 0;
-     bit_pos = 0;
-     rle_v1 = rle_v2 = rle_v3 = 0;
-     while(strip >= strip_tbl) {
-         if(bit_pos <= 0) {
-             bit_pos = 8;
-             bit_buf = *buf1++;
-         }
+ #define AVG_64(dst, src, ref) \
+     AV_WN64A(dst, ((AV_RN64A(src) + AV_RN64A(ref)) >> 1) & 0x7F7F7F7F7F7F7F7FULL)
  
-         bit_pos -= 2;
-         cmd = (bit_buf >> bit_pos) & 0x03;
  
-         if(cmd == 0) {
-             strip++;
-             if(strip >= strip_tbl + FF_ARRAY_ELEMS(strip_tbl)) {
-                 av_log(s->avctx, AV_LOG_WARNING, "out of range strip\n");
-                 break;
-             }
-             memcpy(strip, strip-1, sizeof(*strip));
-             strip->split_flag = 1;
-             strip->split_direction = 0;
-             strip->height = (strip->height > 8 ? ((strip->height+8)>>4)<<3 : 4);
-             continue;
-         } else if(cmd == 1) {
-             strip++;
-             if(strip >= strip_tbl + FF_ARRAY_ELEMS(strip_tbl)) {
-                 av_log(s->avctx, AV_LOG_WARNING, "out of range strip\n");
-                 break;
-             }
-             memcpy(strip, strip-1, sizeof(*strip));
-             strip->split_flag = 1;
-             strip->split_direction = 1;
-             strip->width = (strip->width > 8 ? ((strip->width+8)>>4)<<3 : 4);
-             continue;
-         } else if(cmd == 2) {
-             if(strip->usl7 == 0) {
-                 strip->usl7 = 1;
-                 ref_vectors = NULL;
-                 continue;
-             }
-         } else if(cmd == 3) {
-             if(strip->usl7 == 0) {
-                 strip->usl7 = 1;
-                 ref_vectors = (const signed char*)buf2 + (*buf1 * 2);
-                 buf1++;
-                 continue;
-             }
-         }
+ /*
+  *  Replicate each even pixel as follows:
+  *  ABCDEFGH -> AACCEEGG
+  */
+ static inline uint64_t replicate64(uint64_t a) {
+ #if HAVE_BIGENDIAN
+     a &= 0xFF00FF00FF00FF00ULL;
+     a |= a >> 8;
+ #else
+     a &= 0x00FF00FF00FF00FFULL;
+     a |= a << 8;
+ #endif
+     return a;
+ }
  
-         cur_frm_pos = cur + width * strip->ypos + strip->xpos;
+ static inline uint32_t replicate32(uint32_t a) {
+ #if HAVE_BIGENDIAN
+     a &= 0xFF00FF00UL;
+     a |= a >> 8;
+ #else
+     a &= 0x00FF00FFUL;
+     a |= a << 8;
+ #endif
+     return a;
+ }
  
-         if((blks_width = strip->width) < 0)
-             blks_width += 3;
-         blks_width >>= 2;
-         blks_height = strip->height;
  
-         if(ref_vectors != NULL) {
-             ref_frm_pos = ref + (ref_vectors[0] + strip->ypos) * width +
-                 ref_vectors[1] + strip->xpos;
-         } else
-             ref_frm_pos = cur_frm_pos - width_tbl[4];
+ /* Fill n lines with 64bit pixel value pix */
+ static inline void fill_64(uint8_t *dst, const uint64_t pix, int32_t n,
+                            int32_t row_offset)
+ {
+     for (; n > 0; dst += row_offset, n--)
+         AV_WN64A(dst, pix);
+ }
  
-         if(cmd == 2) {
-             if(bit_pos <= 0) {
-                 bit_pos = 8;
-                 bit_buf = *buf1++;
-             }
  
-             bit_pos -= 2;
-             cmd = (bit_buf >> bit_pos) & 0x03;
+ /* Error codes for cell decoding. */
+ enum {
+     IV3_NOERR       = 0,
+     IV3_BAD_RLE     = 1,
+     IV3_BAD_DATA    = 2,
+     IV3_BAD_COUNTER = 3,
+     IV3_UNSUPPORTED = 4,
+     IV3_OUT_OF_DATA = 5
+ };
  
-             if(cmd == 0 || ref_vectors != NULL) {
-                 for(lp1 = 0; lp1 < blks_width; lp1++) {
-                     for(i = 0, j = 0; i < blks_height; i++, j += width_tbl[1])
-                         ((uint32_t *)cur_frm_pos)[j] = ((uint32_t *)ref_frm_pos)[j];
-                     cur_frm_pos += 4;
-                     ref_frm_pos += 4;
-                 }
-             } else if(cmd != 1)
-                 return;
-         } else {
-             k = *buf1 >> 4;
-             j = *buf1 & 0x0f;
-             buf1++;
-             lv = j + cb_offset;
-             if((lv - 8) <= 7 && (k == 0 || k == 3 || k == 10)) {
-                 cp2 = s->ModPred + ((lv - 8) << 7);
-                 cp = ref_frm_pos;
-                 for(i = 0; i < blks_width << 2; i++) {
-                     int v = *cp >> 1;
-                     *(cp++) = cp2[v];
-                 }
-             }
  
-             if(k == 1 || k == 4) {
-                 lv = (hdr[j] & 0xf) + cb_offset;
-                 correction_type_sp[0] = s->corrector_type + (lv << 8);
-                 correction_lp[0] = correction + (lv << 8);
-                 lv = (hdr[j] >> 4) + cb_offset;
-                 correction_lp[1] = correction + (lv << 8);
-                 correction_type_sp[1] = s->corrector_type + (lv << 8);
-             } else {
-                 correctionloworder_lp[0] = correctionloworder_lp[1] = correctionloworder + (lv << 8);
-                 correctionhighorder_lp[0] = correctionhighorder_lp[1] = correctionhighorder + (lv << 8);
-                 correction_type_sp[0] = correction_type_sp[1] = s->corrector_type + (lv << 8);
-                 correction_lp[0] = correction_lp[1] = correction + (lv << 8);
-             }
+ #define BUFFER_PRECHECK \
+ if (*data_ptr >= last_ptr) \
+     return IV3_OUT_OF_DATA; \
+ #define RLE_BLOCK_COPY \
+     if (cell->mv_ptr || !skip_flag) \
+         copy_block4(dst, ref, row_offset, row_offset, 4 << v_zoom)
+ #define RLE_BLOCK_COPY_8 \
+     pix64 = AV_RN64A(ref);\
+     if (is_first_row) {/* special prediction case: top line of a cell */\
+         pix64 = replicate64(pix64);\
+         fill_64(dst + row_offset, pix64, 7, row_offset);\
+         AVG_64(dst, ref, dst + row_offset);\
+     } else \
+         fill_64(dst, pix64, 8, row_offset)
+ #define RLE_LINES_COPY \
+     copy_block4(dst, ref, row_offset, row_offset, num_lines << v_zoom)
+ #define RLE_LINES_COPY_M10 \
+     pix64 = AV_RN64A(ref);\
+     if (is_top_of_cell) {\
+         pix64 = replicate64(pix64);\
+         fill_64(dst + row_offset, pix64, (num_lines << 1) - 1, row_offset);\
+         AVG_64(dst, ref, dst + row_offset);\
+     } else \
+         fill_64(dst, pix64, num_lines << 1, row_offset)
+ #define APPLY_DELTA_4 \
+     AV_WN16A(dst + line_offset    , AV_RN16A(ref    ) + delta_tab->deltas[dyad1]);\
+     AV_WN16A(dst + line_offset + 2, AV_RN16A(ref + 2) + delta_tab->deltas[dyad2]);\
+     if (mode >= 3) {\
+         if (is_top_of_cell && !cell->ypos) {\
+             AV_COPY32(dst, dst + row_offset);\
+         } else {\
+             AVG_32(dst, ref, dst + row_offset);\
+         }\
+     }
  
-             switch(k) {
-             case 1:
-             case 0:                    /********** CASE 0 **********/
-                 for( ; blks_height > 0; blks_height -= 4) {
-                     for(lp1 = 0; lp1 < blks_width; lp1++) {
-                         for(lp2 = 0; lp2 < 4; ) {
-                             k = *buf1++;
-                             cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2];
-                             ref_lp = ((uint32_t *)ref_frm_pos) + width_tbl[lp2];
-                             if ((uint8_t *)cur_lp >= cur_end-3)
-                                 break;
-                             switch(correction_type_sp[0][k]) {
-                             case 0:
-                                 *cur_lp = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
-                                 lp2++;
-                                 break;
-                             case 1:
-                                 res = ((av_le2ne16(((unsigned short *)(ref_lp))[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
-                                 ((unsigned short *)cur_lp)[0] = av_le2ne16(res);
-                                 res = ((av_le2ne16(((unsigned short *)(ref_lp))[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
-                                 ((unsigned short *)cur_lp)[1] = av_le2ne16(res);
-                                 buf1++;
-                                 lp2++;
-                                 break;
-                             case 2:
-                                 if(lp2 == 0) {
-                                     for(i = 0, j = 0; i < 2; i++, j += width_tbl[1])
-                                         cur_lp[j] = ref_lp[j];
-                                     lp2 += 2;
-                                 }
-                                 break;
-                             case 3:
-                                 if(lp2 < 2) {
-                                     for(i = 0, j = 0; i < (3 - lp2); i++, j += width_tbl[1])
-                                         cur_lp[j] = ref_lp[j];
-                                     lp2 = 3;
-                                 }
-                                 break;
-                             case 8:
-                                 if(lp2 == 0) {
-                                     RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
-                                     if(rle_v1 == 1 || ref_vectors != NULL) {
-                                         for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
-                                             cur_lp[j] = ref_lp[j];
-                                     }
-                                     RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
-                                     break;
-                                 } else {
-                                     rle_v1 = 1;
-                                     rle_v2 = *buf1 - 1;
-                                 }
-                             case 5:
-                                 LP2_CHECK(buf1,rle_v3,lp2)
-                             case 4:
-                                 for(i = 0, j = 0; i < (4 - lp2); i++, j += width_tbl[1])
-                                     cur_lp[j] = ref_lp[j];
-                                 lp2 = 4;
-                                 break;
-                             case 7:
-                                 if(rle_v3 != 0)
-                                     rle_v3 = 0;
-                                 else {
-                                     buf1--;
-                                     rle_v3 = 1;
-                                 }
-                             case 6:
-                                 if(ref_vectors != NULL) {
-                                     for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
-                                         cur_lp[j] = ref_lp[j];
-                                 }
-                                 lp2 = 4;
-                                 break;
-                             case 9:
-                                 lv1 = *buf1++;
-                                 lv = (lv1 & 0x7F) << 1;
-                                 lv += (lv << 8);
-                                 lv += (lv << 16);
-                                 for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
-                                     cur_lp[j] = lv;
-                                 LV1_CHECK(buf1,rle_v3,lv1,lp2)
-                                 break;
-                             default:
-                                 return;
-                             }
-                         }
+ #define APPLY_DELTA_8 \
+     /* apply two 32-bit VQ deltas to next even line */\
+     if (is_top_of_cell) { \
+         AV_WN32A(dst + row_offset    , \
+                  replicate32(AV_RN32A(ref    )) + delta_tab->deltas_m10[dyad1]);\
+         AV_WN32A(dst + row_offset + 4, \
+                  replicate32(AV_RN32A(ref + 4)) + delta_tab->deltas_m10[dyad2]);\
+     } else { \
+         AV_WN32A(dst + row_offset    , \
+                  AV_RN32A(ref    ) + delta_tab->deltas_m10[dyad1]);\
+         AV_WN32A(dst + row_offset + 4, \
+                  AV_RN32A(ref + 4) + delta_tab->deltas_m10[dyad2]);\
+     } \
+     /* odd lines are not coded but rather interpolated/replicated */\
+     /* first line of the cell on the top of image? - replicate */\
+     /* otherwise - interpolate */\
+     if (is_top_of_cell && !cell->ypos) {\
+         AV_COPY64(dst, dst + row_offset);\
+     } else \
+         AVG_64(dst, ref, dst + row_offset);
+ #define APPLY_DELTA_1011_INTER \
+     if (mode == 10) { \
+         AV_WN32A(dst                 , \
+                  AV_RN32A(dst                 ) + delta_tab->deltas_m10[dyad1]);\
+         AV_WN32A(dst + 4             , \
+                  AV_RN32A(dst + 4             ) + delta_tab->deltas_m10[dyad2]);\
+         AV_WN32A(dst + row_offset    , \
+                  AV_RN32A(dst + row_offset    ) + delta_tab->deltas_m10[dyad1]);\
+         AV_WN32A(dst + row_offset + 4, \
+                  AV_RN32A(dst + row_offset + 4) + delta_tab->deltas_m10[dyad2]);\
+     } else { \
+         AV_WN16A(dst                 , \
+                  AV_RN16A(dst                 ) + delta_tab->deltas[dyad1]);\
+         AV_WN16A(dst + 2             , \
+                  AV_RN16A(dst + 2             ) + delta_tab->deltas[dyad2]);\
+         AV_WN16A(dst + row_offset    , \
+                  AV_RN16A(dst + row_offset    ) + delta_tab->deltas[dyad1]);\
+         AV_WN16A(dst + row_offset + 2, \
+                  AV_RN16A(dst + row_offset + 2) + delta_tab->deltas[dyad2]);\
+     }
  
-                         cur_frm_pos += 4;
-                         ref_frm_pos += 4;
-                     }
  
-                     cur_frm_pos += ((width - blks_width) * 4);
-                     ref_frm_pos += ((width - blks_width) * 4);
+ static int decode_cell_data(Cell *cell, uint8_t *block, uint8_t *ref_block,
+                             int pitch, int h_zoom, int v_zoom, int mode,
+                             const vqEntry *delta[2], int swap_quads[2],
+                             const uint8_t **data_ptr, const uint8_t *last_ptr)
+ {
+     int           x, y, line, num_lines;
+     int           rle_blocks = 0;
+     uint8_t       code, *dst, *ref;
+     const vqEntry *delta_tab;
+     unsigned int  dyad1, dyad2;
+     uint64_t      pix64;
+     int           skip_flag = 0, is_top_of_cell, is_first_row = 1;
+     int           row_offset, blk_row_offset, line_offset;
+     row_offset     =  pitch;
+     blk_row_offset = (row_offset << (2 + v_zoom)) - (cell->width << 2);
+     line_offset    = v_zoom ? row_offset : 0;
+     for (y = 0; y < cell->height; is_first_row = 0, y += 1 + v_zoom) {
+         for (x = 0; x < cell->width; x += 1 + h_zoom) {
+             ref = ref_block;
+             dst = block;
+             if (rle_blocks > 0) {
+                 if (mode <= 4) {
+                     RLE_BLOCK_COPY;
+                 } else if (mode == 10 && !cell->mv_ptr) {
+                     RLE_BLOCK_COPY_8;
                  }
-                 break;
-             case 4:
-             case 3:                    /********** CASE 3 **********/
-                 if(ref_vectors != NULL)
-                     return;
-                 flag1 = 1;
-                 for( ; blks_height > 0; blks_height -= 8) {
-                     for(lp1 = 0; lp1 < blks_width; lp1++) {
-                         for(lp2 = 0; lp2 < 4; ) {
-                             k = *buf1++;
-                             cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
-                             ref_lp = ((uint32_t *)cur_frm_pos) + width_tbl[(lp2 * 2) - 1];
-                             switch(correction_type_sp[lp2 & 0x01][k]) {
-                             case 0:
-                                 cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
-                                 if(lp2 > 0 || flag1 == 0 || strip->ypos != 0)
-                                     cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                 else
-                                     cur_lp[0] = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
-                                 lp2++;
-                                 break;
-                             case 1:
-                                 res = ((av_le2ne16(((unsigned short *)ref_lp)[0]) >> 1) + correction_lp[lp2 & 0x01][*buf1]) << 1;
-                                 ((unsigned short *)cur_lp)[width_tbl[2]] = av_le2ne16(res);
-                                 res = ((av_le2ne16(((unsigned short *)ref_lp)[1]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1;
-                                 ((unsigned short *)cur_lp)[width_tbl[2]+1] = av_le2ne16(res);
-                                 if(lp2 > 0 || flag1 == 0 || strip->ypos != 0)
-                                     cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                 else
-                                     cur_lp[0] = cur_lp[width_tbl[1]];
-                                 buf1++;
-                                 lp2++;
-                                 break;
-                             case 2:
-                                 if(lp2 == 0) {
-                                     for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
-                                         cur_lp[j] = *ref_lp;
-                                     lp2 += 2;
-                                 }
-                                 break;
-                             case 3:
-                                 if(lp2 < 2) {
-                                     for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1])
-                                         cur_lp[j] = *ref_lp;
-                                     lp2 = 3;
-                                 }
-                                 break;
-                             case 6:
-                                 lp2 = 4;
-                                 break;
-                             case 7:
-                                 if(rle_v3 != 0)
-                                     rle_v3 = 0;
-                                 else {
-                                     buf1--;
-                                     rle_v3 = 1;
+                 rle_blocks--;
+             } else {
+                 for (line = 0; line < 4;) {
+                     num_lines = 1;
+                     is_top_of_cell = is_first_row && !line;
+                     /* select primary VQ table for odd, secondary for even lines */
+                     if (mode <= 4)
+                         delta_tab = delta[line & 1];
+                     else
+                         delta_tab = delta[1];
+                     BUFFER_PRECHECK;
+                     code = bytestream_get_byte(data_ptr);
+                     if (code < 248) {
+                         if (code < delta_tab->num_dyads) {
+                             BUFFER_PRECHECK;
+                             dyad1 = bytestream_get_byte(data_ptr);
+                             dyad2 = code;
+                             if (dyad1 > delta_tab->num_dyads || dyad1 >= 248)
+                                 return IV3_BAD_DATA;
+                         } else {
+                             /* process QUADS */
+                             code -= delta_tab->num_dyads;
+                             dyad1 = code / delta_tab->quad_exp;
+                             dyad2 = code % delta_tab->quad_exp;
+                             if (swap_quads[line & 1])
+                                 FFSWAP(unsigned int, dyad1, dyad2);
+                         }
+                         if (mode <= 4) {
+                             APPLY_DELTA_4;
+                         } else if (mode == 10 && !cell->mv_ptr) {
+                             APPLY_DELTA_8;
+                         } else {
+                             APPLY_DELTA_1011_INTER;
+                         }
+                     } else {
+                         /* process RLE codes */
+                         switch (code) {
+                         case RLE_ESC_FC:
+                             skip_flag  = 0;
+                             rle_blocks = 1;
+                             code       = 253;
+                             /* FALLTHROUGH */
+                         case RLE_ESC_FF:
+                         case RLE_ESC_FE:
+                         case RLE_ESC_FD:
+                             num_lines = 257 - code - line;
+                             if (num_lines <= 0)
+                                 return IV3_BAD_RLE;
+                             if (mode <= 4) {
+                                 RLE_LINES_COPY;
+                             } else if (mode == 10 && !cell->mv_ptr) {
+                                 RLE_LINES_COPY_M10;
+                             }
+                             break;
+                         case RLE_ESC_FB:
+                             BUFFER_PRECHECK;
+                             code = bytestream_get_byte(data_ptr);
+                             rle_blocks = (code & 0x1F) - 1; /* set block counter */
+                             if (code >= 64 || rle_blocks < 0)
+                                 return IV3_BAD_COUNTER;
+                             skip_flag = code & 0x20;
+                             num_lines = 4 - line; /* enforce next block processing */
+                             if (mode >= 10 || (cell->mv_ptr || !skip_flag)) {
+                                 if (mode <= 4) {
+                                     RLE_LINES_COPY;
+                                 } else if (mode == 10 && !cell->mv_ptr) {
+                                     RLE_LINES_COPY_M10;
                                  }
-                                 lp2 = 4;
-                                 break;
-                             case 8:
-                                 if(lp2 == 0) {
-                                     RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
-                                     if(rle_v1 == 1) {
-                                         for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
-                                             cur_lp[j] = ref_lp[j];
-                                     }
-                                     RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
-                                     break;
-                                 } else {
-                                     rle_v2 = (*buf1) - 1;
-                                     rle_v1 = 1;
+                             }
+                             break;
+                         case RLE_ESC_F9:
+                             skip_flag  = 1;
+                             rle_blocks = 1;
+                             /* FALLTHROUGH */
+                         case RLE_ESC_FA:
+                             if (line)
+                                 return IV3_BAD_RLE;
+                             num_lines = 4; /* enforce next block processing */
+                             if (cell->mv_ptr) {
+                                 if (mode <= 4) {
+                                     RLE_LINES_COPY;
+                                 } else if (mode == 10 && !cell->mv_ptr) {
+                                     RLE_LINES_COPY_M10;
                                  }
-                             case 5:
-                                 LP2_CHECK(buf1,rle_v3,lp2)
-                             case 4:
-                                 for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1])
-                                     cur_lp[j] = *ref_lp;
-                                 lp2 = 4;
-                                 break;
-                             case 9:
-                                 av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
-                                 lv1 = *buf1++;
-                                 lv = (lv1 & 0x7F) << 1;
-                                 lv += (lv << 8);
-                                 lv += (lv << 16);
-                                 for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
-                                     cur_lp[j] = lv;
-                                 LV1_CHECK(buf1,rle_v3,lv1,lp2)
-                                 break;
-                             default:
-                                 return;
                              }
+                             break;
+                         default:
+                             return IV3_UNSUPPORTED;
                          }
-                         cur_frm_pos += 4;
                      }
  
-                     cur_frm_pos += (((width * 2) - blks_width) * 4);
-                     flag1 = 0;
+                     line += num_lines;
+                     ref  += row_offset * (num_lines << v_zoom);
+                     dst  += row_offset * (num_lines << v_zoom);
                  }
-                 break;
-             case 10:                    /********** CASE 10 **********/
-                 if(ref_vectors == NULL) {
-                     flag1 = 1;
-                     for( ; blks_height > 0; blks_height -= 8) {
-                         for(lp1 = 0; lp1 < blks_width; lp1 += 2) {
-                             for(lp2 = 0; lp2 < 4; ) {
-                                 k = *buf1++;
-                                 cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
-                                 ref_lp = ((uint32_t *)cur_frm_pos) + width_tbl[(lp2 * 2) - 1];
-                                 lv1 = ref_lp[0];
-                                 lv2 = ref_lp[1];
-                                 if(lp2 == 0 && flag1 != 0) {
- #if HAVE_BIGENDIAN
-                                     lv1 = lv1 & 0xFF00FF00;
-                                     lv1 = (lv1 >> 8) | lv1;
-                                     lv2 = lv2 & 0xFF00FF00;
-                                     lv2 = (lv2 >> 8) | lv2;
- #else
-                                     lv1 = lv1 & 0x00FF00FF;
-                                     lv1 = (lv1 << 8) | lv1;
-                                     lv2 = lv2 & 0x00FF00FF;
-                                     lv2 = (lv2 << 8) | lv2;
- #endif
-                                 }
-                                 switch(correction_type_sp[lp2 & 0x01][k]) {
-                                 case 0:
-                                     cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
-                                     cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(lv2) >> 1) + correctionhighorder_lp[lp2 & 0x01][k]) << 1);
-                                     if(lp2 > 0 || strip->ypos != 0 || flag1 == 0) {
-                                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
-                                     } else {
-                                         cur_lp[0] = cur_lp[width_tbl[1]];
-                                         cur_lp[1] = cur_lp[width_tbl[1]+1];
-                                     }
-                                     lp2++;
-                                     break;
-                                 case 1:
-                                     cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(lv1) >> 1) + correctionloworder_lp[lp2 & 0x01][*buf1]) << 1);
-                                     cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(lv2) >> 1) + correctionloworder_lp[lp2 & 0x01][k]) << 1);
-                                     if(lp2 > 0 || strip->ypos != 0 || flag1 == 0) {
-                                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
-                                     } else {
-                                         cur_lp[0] = cur_lp[width_tbl[1]];
-                                         cur_lp[1] = cur_lp[width_tbl[1]+1];
-                                     }
-                                     buf1++;
-                                     lp2++;
-                                     break;
-                                 case 2:
-                                     if(lp2 == 0) {
-                                         if(flag1 != 0) {
-                                             for(i = 0, j = width_tbl[1]; i < 3; i++, j += width_tbl[1]) {
-                                                 cur_lp[j] = lv1;
-                                                 cur_lp[j+1] = lv2;
-                                             }
-                                             cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                             cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
-                                         } else {
-                                             for(i = 0, j = 0; i < 4; i++, j += width_tbl[1]) {
-                                                 cur_lp[j] = lv1;
-                                                 cur_lp[j+1] = lv2;
-                                             }
-                                         }
-                                         lp2 += 2;
-                                     }
-                                     break;
-                                 case 3:
-                                     if(lp2 < 2) {
-                                         if(lp2 == 0 && flag1 != 0) {
-                                             for(i = 0, j = width_tbl[1]; i < 5; i++, j += width_tbl[1]) {
-                                                 cur_lp[j] = lv1;
-                                                 cur_lp[j+1] = lv2;
-                                             }
-                                             cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                             cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
-                                         } else {
-                                             for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1]) {
-                                                 cur_lp[j] = lv1;
-                                                 cur_lp[j+1] = lv2;
-                                             }
-                                         }
-                                         lp2 = 3;
-                                     }
-                                     break;
-                                 case 8:
-                                     if(lp2 == 0) {
-                                         RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
-                                         if(rle_v1 == 1) {
-                                             if(flag1 != 0) {
-                                                 for(i = 0, j = width_tbl[1]; i < 7; i++, j += width_tbl[1]) {
-                                                     cur_lp[j] = lv1;
-                                                     cur_lp[j+1] = lv2;
-                                                 }
-                                                 cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                                 cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
-                                             } else {
-                                                 for(i = 0, j = 0; i < 8; i++, j += width_tbl[1]) {
-                                                     cur_lp[j] = lv1;
-                                                     cur_lp[j+1] = lv2;
-                                                 }
-                                             }
-                                         }
-                                         RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
-                                         break;
-                                     } else {
-                                         rle_v1 = 1;
-                                         rle_v2 = (*buf1) - 1;
-                                     }
-                                 case 5:
-                                     LP2_CHECK(buf1,rle_v3,lp2)
-                                 case 4:
-                                     if(lp2 == 0 && flag1 != 0) {
-                                         for(i = 0, j = width_tbl[1]; i < 7; i++, j += width_tbl[1]) {
-                                             cur_lp[j] = lv1;
-                                             cur_lp[j+1] = lv2;
-                                         }
-                                         cur_lp[0] = ((cur_lp[-width_tbl[1]] >> 1) + (cur_lp[width_tbl[1]] >> 1)) & 0xFEFEFEFE;
-                                         cur_lp[1] = ((cur_lp[-width_tbl[1]+1] >> 1) + (cur_lp[width_tbl[1]+1] >> 1)) & 0xFEFEFEFE;
-                                     } else {
-                                         for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1]) {
-                                             cur_lp[j] = lv1;
-                                             cur_lp[j+1] = lv2;
-                                         }
-                                     }
-                                     lp2 = 4;
-                                     break;
-                                 case 6:
-                                     lp2 = 4;
-                                     break;
-                                 case 7:
-                                     if(lp2 == 0) {
-                                         if(rle_v3 != 0)
-                                             rle_v3 = 0;
-                                         else {
-                                             buf1--;
-                                             rle_v3 = 1;
-                                         }
-                                         lp2 = 4;
-                                     }
-                                     break;
-                                 case 9:
-                                     av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
-                                     lv1 = *buf1;
-                                     lv = (lv1 & 0x7F) << 1;
-                                     lv += (lv << 8);
-                                     lv += (lv << 16);
-                                     for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
-                                         cur_lp[j] = lv;
-                                     LV1_CHECK(buf1,rle_v3,lv1,lp2)
-                                     break;
-                                 default:
-                                     return;
-                                 }
-                             }
+             }
  
-                             cur_frm_pos += 8;
-                         }
+             /* move to next horizontal block */
+             block     += 4 << h_zoom;
+             ref_block += 4 << h_zoom;
+         }
  
-                         cur_frm_pos += (((width * 2) - blks_width) * 4);
-                         flag1 = 0;
-                     }
-                 } else {
-                     for( ; blks_height > 0; blks_height -= 8) {
-                         for(lp1 = 0; lp1 < blks_width; lp1 += 2) {
-                             for(lp2 = 0; lp2 < 4; ) {
-                                 k = *buf1++;
-                                 cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
-                                 ref_lp = ((uint32_t *)ref_frm_pos) + width_tbl[lp2 * 2];
-                                 switch(correction_type_sp[lp2 & 0x01][k]) {
-                                 case 0:
-                                     lv1 = correctionloworder_lp[lp2 & 0x01][k];
-                                     lv2 = correctionhighorder_lp[lp2 & 0x01][k];
-                                     cur_lp[0] = av_le2ne32(((av_le2ne32(ref_lp[0]) >> 1) + lv1) << 1);
-                                     cur_lp[1] = av_le2ne32(((av_le2ne32(ref_lp[1]) >> 1) + lv2) << 1);
-                                     cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
-                                     cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
-                                     lp2++;
-                                     break;
-                                 case 1:
-                                     lv1 = correctionloworder_lp[lp2 & 0x01][*buf1++];
-                                     lv2 = correctionloworder_lp[lp2 & 0x01][k];
-                                     cur_lp[0] = av_le2ne32(((av_le2ne32(ref_lp[0]) >> 1) + lv1) << 1);
-                                     cur_lp[1] = av_le2ne32(((av_le2ne32(ref_lp[1]) >> 1) + lv2) << 1);
-                                     cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]]) >> 1) + lv1) << 1);
-                                     cur_lp[width_tbl[1]+1] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]+1]) >> 1) + lv2) << 1);
-                                     lp2++;
-                                     break;
-                                 case 2:
-                                     if(lp2 == 0) {
-                                         for(i = 0, j = 0; i < 4; i++, j += width_tbl[1]) {
-                                             cur_lp[j] = ref_lp[j];
-                                             cur_lp[j+1] = ref_lp[j+1];
-                                         }
-                                         lp2 += 2;
-                                     }
-                                     break;
-                                 case 3:
-                                     if(lp2 < 2) {
-                                         for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1]) {
-                                             cur_lp[j] = ref_lp[j];
-                                             cur_lp[j+1] = ref_lp[j+1];
-                                         }
-                                         lp2 = 3;
-                                     }
-                                     break;
-                                 case 8:
-                                     if(lp2 == 0) {
-                                         RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
-                                         for(i = 0, j = 0; i < 8; i++, j += width_tbl[1]) {
-                                             ((uint32_t *)cur_frm_pos)[j] = ((uint32_t *)ref_frm_pos)[j];
-                                             ((uint32_t *)cur_frm_pos)[j+1] = ((uint32_t *)ref_frm_pos)[j+1];
-                                         }
-                                         RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
-                                         break;
-                                     } else {
-                                         rle_v1 = 1;
-                                         rle_v2 = (*buf1) - 1;
-                                     }
-                                 case 5:
-                                 case 7:
-                                     LP2_CHECK(buf1,rle_v3,lp2)
-                                 case 6:
-                                 case 4:
-                                     for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1]) {
-                                         cur_lp[j] = ref_lp[j];
-                                         cur_lp[j+1] = ref_lp[j+1];
-                                     }
-                                     lp2 = 4;
-                                     break;
-                                 case 9:
-                                     av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
-                                     lv1 = *buf1;
-                                     lv = (lv1 & 0x7F) << 1;
-                                     lv += (lv << 8);
-                                     lv += (lv << 16);
-                                     for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
-                                         ((uint32_t *)cur_frm_pos)[j] = ((uint32_t *)cur_frm_pos)[j+1] = lv;
-                                     LV1_CHECK(buf1,rle_v3,lv1,lp2)
-                                     break;
-                                 default:
-                                     return;
-                                 }
-                             }
+         /* move to next line of blocks */
+         ref_block += blk_row_offset;
+         block     += blk_row_offset;
+     }
+     return IV3_NOERR;
+ }
  
-                             cur_frm_pos += 8;
-                             ref_frm_pos += 8;
-                         }
  
-                         cur_frm_pos += (((width * 2) - blks_width) * 4);
-                         ref_frm_pos += (((width * 2) - blks_width) * 4);
-                     }
-                 }
-                 break;
-             case 11:                    /********** CASE 11 **********/
-                 if(ref_vectors == NULL)
-                     return;
-                 for( ; blks_height > 0; blks_height -= 8) {
-                     for(lp1 = 0; lp1 < blks_width; lp1++) {
-                         for(lp2 = 0; lp2 < 4; ) {
-                             k = *buf1++;
-                             cur_lp = ((uint32_t *)cur_frm_pos) + width_tbl[lp2 * 2];
-                             ref_lp = ((uint32_t *)ref_frm_pos) + width_tbl[lp2 * 2];
-                             switch(correction_type_sp[lp2 & 0x01][k]) {
-                             case 0:
-                                 cur_lp[0] = av_le2ne32(((av_le2ne32(*ref_lp) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
-                                 cur_lp[width_tbl[1]] = av_le2ne32(((av_le2ne32(ref_lp[width_tbl[1]]) >> 1) + correction_lp[lp2 & 0x01][k]) << 1);
-                                 lp2++;
-                                 break;
-                             case 1:
-                                 lv1 = (unsigned short)(correction_lp[lp2 & 0x01][*buf1++]);
-                                 lv2 = (unsigned short)(correction_lp[lp2 & 0x01][k]);
-                                 res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[0]) >> 1) + lv1) << 1);
-                                 ((unsigned short *)cur_lp)[0] = av_le2ne16(res);
-                                 res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[1]) >> 1) + lv2) << 1);
-                                 ((unsigned short *)cur_lp)[1] = av_le2ne16(res);
-                                 res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[width_tbl[2]]) >> 1) + lv1) << 1);
-                                 ((unsigned short *)cur_lp)[width_tbl[2]] = av_le2ne16(res);
-                                 res = (unsigned short)(((av_le2ne16(((unsigned short *)ref_lp)[width_tbl[2]+1]) >> 1) + lv2) << 1);
-                                 ((unsigned short *)cur_lp)[width_tbl[2]+1] = av_le2ne16(res);
-                                 lp2++;
-                                 break;
-                             case 2:
-                                 if(lp2 == 0) {
-                                     for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
-                                         cur_lp[j] = ref_lp[j];
-                                     lp2 += 2;
-                                 }
-                                 break;
+ /**
+  *  Decode a vector-quantized cell.
+  *  It consists of several routines, each of which handles one or more "modes"
+  *  with which a cell can be encoded.
+  *
+  *  @param ctx      pointer to the decoder context
+  *  @param avctx    ptr to the AVCodecContext
+  *  @param plane    pointer to the plane descriptor
+  *  @param cell     pointer to the cell  descriptor
+  *  @param data_ptr pointer to the compressed data
+  *  @param last_ptr pointer to the last byte to catch reads past end of buffer
+  *  @return         number of consumed bytes or negative number in case of error
+  */
+ static int decode_cell(Indeo3DecodeContext *ctx, AVCodecContext *avctx,
+                        Plane *plane, Cell *cell, const uint8_t *data_ptr,
+                        const uint8_t *last_ptr)
+ {
+     int           x, mv_x, mv_y, mode, vq_index, prim_indx, second_indx;
+     int           zoom_fac;
+     int           offset, error = 0, swap_quads[2];
+     uint8_t       code, *block, *ref_block = 0;
+     const vqEntry *delta[2];
+     const uint8_t *data_start = data_ptr;
+     /* get coding mode and VQ table index from the VQ descriptor byte */
+     code     = *data_ptr++;
+     mode     = code >> 4;
+     vq_index = code & 0xF;
+     /* setup output and reference pointers */
+     offset = (cell->ypos << 2) * plane->pitch + (cell->xpos << 2);
+     block  =  plane->pixels[ctx->buf_sel] + offset;
+     if (!cell->mv_ptr) {
+         /* use previous line as reference for INTRA cells */
+         ref_block = block - plane->pitch;
+     } else if (mode >= 10) {
+         /* for mode 10 and 11 INTER first copy the predicted cell into the current one */
+         /* so we don't need to do data copying for each RLE code later */
+         copy_cell(ctx, plane, cell);
+     } else {
+         /* set the pointer to the reference pixels for modes 0-4 INTER */
+         mv_y      = cell->mv_ptr[0];
+         mv_x      = cell->mv_ptr[1];
+         offset   += mv_y * plane->pitch + mv_x;
+         ref_block = plane->pixels[ctx->buf_sel ^ 1] + offset;
+     }
  
-                             case 3:
-                                 if(lp2 < 2) {
-                                     for(i = 0, j = 0; i < 6 - (lp2 * 2); i++, j += width_tbl[1])
-                                         cur_lp[j] = ref_lp[j];
-                                     lp2 = 3;
-                                 }
-                                 break;
+     /* select VQ tables as follows: */
+     /* modes 0 and 3 use only the primary table for all lines in a block */
+     /* while modes 1 and 4 switch between primary and secondary tables on alternate lines */
+     if (mode == 1 || mode == 4) {
+         code        = ctx->alt_quant[vq_index];
+         prim_indx   = (code >> 4)  + ctx->cb_offset;
+         second_indx = (code & 0xF) + ctx->cb_offset;
+     } else {
+         vq_index += ctx->cb_offset;
+         prim_indx = second_indx = vq_index;
+     }
  
-                             case 8:
-                                 if(lp2 == 0) {
-                                     RLE_V3_CHECK(buf1,rle_v1,rle_v2,rle_v3)
+     if (prim_indx >= 24 || second_indx >= 24) {
+         av_log(avctx, AV_LOG_ERROR, "Invalid VQ table indexes! Primary: %d, secondary: %d!\n",
+                prim_indx, second_indx);
+         return AVERROR_INVALIDDATA;
+     }
  
-                                     for(i = 0, j = 0; i < 8; i++, j += width_tbl[1])
-                                         cur_lp[j] = ref_lp[j];
+     delta[0] = &vq_tab[second_indx];
+     delta[1] = &vq_tab[prim_indx];
+     swap_quads[0] = second_indx >= 16;
+     swap_quads[1] = prim_indx   >= 16;
  
-                                     RLE_V2_CHECK(buf1,rle_v2, rle_v3,lp2)
-                                     break;
-                                 } else {
-                                     rle_v1 = 1;
-                                     rle_v2 = (*buf1) - 1;
-                                 }
-                             case 5:
-                             case 7:
-                                 LP2_CHECK(buf1,rle_v3,lp2)
-                             case 4:
-                             case 6:
-                                 for(i = 0, j = 0; i < 8 - (lp2 * 2); i++, j += width_tbl[1])
-                                     cur_lp[j] = ref_lp[j];
-                                 lp2 = 4;
-                                 break;
-                             case 9:
-                                 av_log(s->avctx, AV_LOG_ERROR, "UNTESTED.\n");
-                                 lv1 = *buf1++;
-                                 lv = (lv1 & 0x7F) << 1;
-                                 lv += (lv << 8);
-                                 lv += (lv << 16);
-                                 for(i = 0, j = 0; i < 4; i++, j += width_tbl[1])
-                                     cur_lp[j] = lv;
-                                 LV1_CHECK(buf1,rle_v3,lv1,lp2)
-                                 break;
-                             default:
-                                 return;
-                             }
-                         }
+     /* requantize the prediction if VQ index of this cell differs from VQ index */
+     /* of the predicted cell in order to avoid overflows. */
+     if (vq_index >= 8 && ref_block) {
+         for (x = 0; x < cell->width << 2; x++)
+             ref_block[x] = requant_tab[vq_index & 7][ref_block[x]];
+     }
  
-                         cur_frm_pos += 4;
-                         ref_frm_pos += 4;
-                     }
+     error = IV3_NOERR;
  
-                     cur_frm_pos += (((width * 2) - blks_width) * 4);
-                     ref_frm_pos += (((width * 2) - blks_width) * 4);
-                 }
-                 break;
+     switch (mode) {
+     case 0: /*------------------ MODES 0 & 1 (4x4 block processing) --------------------*/
+     case 1:
+     case 3: /*------------------ MODES 3 & 4 (4x8 block processing) --------------------*/
+     case 4:
+         if (mode >= 3 && cell->mv_ptr) {
+             av_log(avctx, AV_LOG_ERROR, "Attempt to apply Mode 3/4 to an INTER cell!\n");
+             return AVERROR_INVALIDDATA;
+         }
  
-             default:
-                 return;
+         zoom_fac = mode >= 3;
+         error = decode_cell_data(cell, block, ref_block, plane->pitch, 0, zoom_fac,
+                                  mode, delta, swap_quads, &data_ptr, last_ptr);
+         break;
+     case 10: /*-------------------- MODE 10 (8x8 block processing) ---------------------*/
+     case 11: /*----------------- MODE 11 (4x8 INTER block processing) ------------------*/
+         if (mode == 10 && !cell->mv_ptr) { /* MODE 10 INTRA processing */
+             error = decode_cell_data(cell, block, ref_block, plane->pitch, 1, 1,
+                                      mode, delta, swap_quads, &data_ptr, last_ptr);
+         } else { /* mode 10 and 11 INTER processing */
+             if (mode == 11 && !cell->mv_ptr) {
+                av_log(avctx, AV_LOG_ERROR, "Attempt to use Mode 11 for an INTRA cell!\n");
+                return AVERROR_INVALIDDATA;
              }
+             zoom_fac = mode == 10;
+             error = decode_cell_data(cell, block, ref_block, plane->pitch,
+                                      zoom_fac, 1, mode, delta, swap_quads,
+                                      &data_ptr, last_ptr);
          }
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "Unsupported coding mode: %d\n", mode);
+         return AVERROR_INVALIDDATA;
+     }//switch mode
+     switch (error) {
+     case IV3_BAD_RLE:
+         av_log(avctx, AV_LOG_ERROR, "Mode %d: RLE code %X is not allowed at the current line\n",
+                mode, data_ptr[-1]);
+         return AVERROR_INVALIDDATA;
+     case IV3_BAD_DATA:
+         av_log(avctx, AV_LOG_ERROR, "Mode %d: invalid VQ data\n", mode);
+         return AVERROR_INVALIDDATA;
+     case IV3_BAD_COUNTER:
+         av_log(avctx, AV_LOG_ERROR, "Mode %d: RLE-FB invalid counter: %d\n", mode, code);
+         return AVERROR_INVALIDDATA;
+     case IV3_UNSUPPORTED:
+         av_log(avctx, AV_LOG_ERROR, "Mode %d: unsupported RLE code: %X\n", mode, data_ptr[-1]);
+         return AVERROR_INVALIDDATA;
+     case IV3_OUT_OF_DATA:
+         av_log(avctx, AV_LOG_ERROR, "Mode %d: attempt to read past end of buffer\n", mode);
+         return AVERROR_INVALIDDATA;
+     }
  
-         for( ; strip >= strip_tbl; strip--) {
-             if(strip->split_flag != 0) {
-                 strip->split_flag = 0;
-                 strip->usl7 = (strip-1)->usl7;
-                 if(strip->split_direction) {
-                     strip->xpos += strip->width;
-                     strip->width = (strip-1)->width - strip->width;
-                     if(region_160_width <= strip->xpos && width < strip->width + strip->xpos)
-                         strip->width = width - strip->xpos;
-                 } else {
-                     strip->ypos += strip->height;
-                     strip->height = (strip-1)->height - strip->height;
+     return data_ptr - data_start; /* report number of bytes consumed from the input buffer */
+ }
+ /* Binary tree codes. */
+ enum {
+     H_SPLIT    = 0,
+     V_SPLIT    = 1,
+     INTRA_NULL = 2,
+     INTER_DATA = 3
+ };
+ #define SPLIT_CELL(size, new_size) (new_size) = ((size) > 2) ? ((((size) + 2) >> 2) << 1) : 1
+ #define UPDATE_BITPOS(n) \
+     ctx->skip_bits  += (n); \
+     ctx->need_resync = 1
+ #define RESYNC_BITSTREAM \
+     if (ctx->need_resync && !(get_bits_count(&ctx->gb) & 7)) { \
+         skip_bits_long(&ctx->gb, ctx->skip_bits);              \
+         ctx->skip_bits   = 0;                                  \
+         ctx->need_resync = 0;                                  \
+     }
+ #define CHECK_CELL \
+     if (curr_cell.xpos + curr_cell.width > (plane->width >> 2) ||               \
+         curr_cell.ypos + curr_cell.height > (plane->height >> 2)) {             \
+         av_log(avctx, AV_LOG_ERROR, "Invalid cell: x=%d, y=%d, w=%d, h=%d\n",   \
+                curr_cell.xpos, curr_cell.ypos, curr_cell.width, curr_cell.height); \
+         return AVERROR_INVALIDDATA;                                                              \
+     }
+ static int parse_bintree(Indeo3DecodeContext *ctx, AVCodecContext *avctx,
+                          Plane *plane, int code, Cell *ref_cell,
+                          const int depth, const int strip_width)
+ {
+     Cell    curr_cell;
+     int     bytes_used;
+     if (depth <= 0) {
+         av_log(avctx, AV_LOG_ERROR, "Stack overflow (corrupted binary tree)!\n");
+         return AVERROR_INVALIDDATA; // unwind recursion
+     }
+     curr_cell = *ref_cell; // clone parent cell
+     if (code == H_SPLIT) {
+         SPLIT_CELL(ref_cell->height, curr_cell.height);
+         ref_cell->ypos   += curr_cell.height;
+         ref_cell->height -= curr_cell.height;
+     } else if (code == V_SPLIT) {
+         if (curr_cell.width > strip_width) {
+             /* split strip */
+             curr_cell.width = (curr_cell.width <= (strip_width << 1) ? 1 : 2) * strip_width;
+         } else
+             SPLIT_CELL(ref_cell->width, curr_cell.width);
+         ref_cell->xpos  += curr_cell.width;
+         ref_cell->width -= curr_cell.width;
+     }
+     while (1) { /* loop until return */
+         RESYNC_BITSTREAM;
+         switch (code = get_bits(&ctx->gb, 2)) {
+         case H_SPLIT:
+         case V_SPLIT:
+             if (parse_bintree(ctx, avctx, plane, code, &curr_cell, depth - 1, strip_width))
+                 return AVERROR_INVALIDDATA;
+             break;
+         case INTRA_NULL:
+             if (!curr_cell.tree) { /* MC tree INTRA code */
+                 curr_cell.mv_ptr = 0; /* mark the current strip as INTRA */
+                 curr_cell.tree   = 1; /* enter the VQ tree */
+             } else { /* VQ tree NULL code */
+                 RESYNC_BITSTREAM;
+                 code = get_bits(&ctx->gb, 2);
+                 if (code >= 2) {
+                     av_log(avctx, AV_LOG_ERROR, "Invalid VQ_NULL code: %d\n", code);
+                     return AVERROR_INVALIDDATA;
                  }
-                 break;
+                 if (code == 1)
+                     av_log(avctx, AV_LOG_ERROR, "SkipCell procedure not implemented yet!\n");
+                 CHECK_CELL
+                 copy_cell(ctx, plane, &curr_cell);
+                 return 0;
+             }
+             break;
+         case INTER_DATA:
+             if (!curr_cell.tree) { /* MC tree INTER code */
+                 /* get motion vector index and setup the pointer to the mv set */
+                 if (!ctx->need_resync)
+                     ctx->next_cell_data = &ctx->gb.buffer[(get_bits_count(&ctx->gb) + 7) >> 3];
+                 curr_cell.mv_ptr = &ctx->mc_vectors[*(ctx->next_cell_data++) << 1];
+                 curr_cell.tree   = 1; /* enter the VQ tree */
+                 UPDATE_BITPOS(8);
+             } else { /* VQ tree DATA code */
+                 if (!ctx->need_resync)
+                     ctx->next_cell_data = &ctx->gb.buffer[(get_bits_count(&ctx->gb) + 7) >> 3];
+                 CHECK_CELL
+                 bytes_used = decode_cell(ctx, avctx, plane, &curr_cell,
+                                          ctx->next_cell_data, ctx->last_byte);
+                 if (bytes_used < 0)
+                     return AVERROR_INVALIDDATA;
+                 UPDATE_BITPOS(bytes_used << 3);
+                 ctx->next_cell_data += bytes_used;
+                 return 0;
              }
+             break;
          }
-     }
+     }//while
+     return 0;
  }
  
- static av_cold int indeo3_decode_init(AVCodecContext *avctx)
+ static int decode_plane(Indeo3DecodeContext *ctx, AVCodecContext *avctx,
+                         Plane *plane, const uint8_t *data, int32_t data_size,
+                         int32_t strip_width)
  {
-     Indeo3DecodeContext *s = avctx->priv_data;
-     int ret = 0;
+     Cell            curr_cell;
+     int             num_vectors;
  
-     s->avctx = avctx;
-     s->width = avctx->width;
-     s->height = avctx->height;
-     avctx->pix_fmt = PIX_FMT_YUV410P;
-     avcodec_get_frame_defaults(&s->frame);
+     /* each plane data starts with mc_vector_count field, */
+     /* an optional array of motion vectors followed by the vq data */
+     num_vectors = bytestream_get_le32(&data);
+     ctx->mc_vectors  = num_vectors ? data : 0;
+     /* init the bitreader */
+     init_get_bits(&ctx->gb, &data[num_vectors * 2], data_size << 3);
+     ctx->skip_bits   = 0;
+     ctx->need_resync = 0;
+     ctx->last_byte = data + data_size - 1;
  
-     if (!(ret = build_modpred(s)))
-         ret = iv_alloc_frames(s);
-     if (ret)
-         iv_free_func(s);
+     /* initialize the 1st cell and set its dimensions to whole plane */
+     curr_cell.xpos   = curr_cell.ypos = 0;
+     curr_cell.width  = plane->width  >> 2;
+     curr_cell.height = plane->height >> 2;
+     curr_cell.tree   = 0; // we are in the MC tree now
+     curr_cell.mv_ptr = 0; // no motion vector = INTRA cell
  
-     return ret;
+     return parse_bintree(ctx, avctx, plane, INTRA_NULL, &curr_cell, CELL_STACK_MAX, strip_width);
  }
  
- static int iv_decode_frame(AVCodecContext *avctx,
-                            const uint8_t *buf, int buf_size)
+ #define OS_HDR_ID   MKBETAG('F', 'R', 'M', 'H')
+ static int decode_frame_headers(Indeo3DecodeContext *ctx, AVCodecContext *avctx,
+                                 const uint8_t *buf, int buf_size)
  {
-     Indeo3DecodeContext *s = avctx->priv_data;
-     unsigned int image_width, image_height,
-                  chroma_width, chroma_height;
-     unsigned int flags, cb_offset, data_size,
-                   y_offset, v_offset, u_offset, mc_vector_count;
-     const uint8_t *hdr_pos, *buf_pos;
-     buf_pos = buf;
-     buf_pos += 18; /* skip OS header (16 bytes) and version number */
-     flags = bytestream_get_le16(&buf_pos);
-     data_size = bytestream_get_le32(&buf_pos);
-     cb_offset = *buf_pos++;
-     buf_pos += 3; /* skip reserved byte and checksum */
-     image_height = bytestream_get_le16(&buf_pos);
-     image_width  = bytestream_get_le16(&buf_pos);
-     if(av_image_check_size(image_width, image_height, 0, avctx))
-         return -1;
-     if (image_width != avctx->width || image_height != avctx->height) {
-         int ret;
-         avcodec_set_dimensions(avctx, image_width, image_height);
-         s->width  = avctx->width;
-         s->height = avctx->height;
-         ret = iv_alloc_frames(s);
-         if (ret < 0) {
-             s->width = s->height = 0;
-             return ret;
-         }
+     const uint8_t   *buf_ptr = buf, *bs_hdr;
+     uint32_t        frame_num, word2, check_sum, data_size;
+     uint32_t        y_offset, u_offset, v_offset, starts[3], ends[3];
+     uint16_t        height, width;
+     int             i, j;
+     /* parse and check the OS header */
+     frame_num = bytestream_get_le32(&buf_ptr);
+     word2     = bytestream_get_le32(&buf_ptr);
+     check_sum = bytestream_get_le32(&buf_ptr);
+     data_size = bytestream_get_le32(&buf_ptr);
+     if ((frame_num ^ word2 ^ data_size ^ OS_HDR_ID) != check_sum) {
+         av_log(avctx, AV_LOG_ERROR, "OS header checksum mismatch!\n");
+         return AVERROR_INVALIDDATA;
      }
  
-     chroma_height = ((image_height >> 2) + 3) & 0x7ffc;
-     chroma_width = ((image_width >> 2) + 3) & 0x7ffc;
-     y_offset = bytestream_get_le32(&buf_pos);
-     v_offset = bytestream_get_le32(&buf_pos);
-     u_offset = bytestream_get_le32(&buf_pos);
-     buf_pos += 4; /* reserved */
-     hdr_pos = buf_pos;
-     if(data_size == 0x80) return 4;
-     if(FFMAX3(y_offset, v_offset, u_offset) >= buf_size-16) {
-         av_log(s->avctx, AV_LOG_ERROR, "y/u/v offset outside buffer\n");
-         return -1;
+     /* parse the bitstream header */
+     bs_hdr = buf_ptr;
+     if (bytestream_get_le16(&buf_ptr) != 32) {
+         av_log(avctx, AV_LOG_ERROR, "Unsupported codec version!\n");
+         return AVERROR_INVALIDDATA;
      }
  
-     if(flags & 0x200) {
-         s->cur_frame = s->iv_frame + 1;
-         s->ref_frame = s->iv_frame;
-     } else {
-         s->cur_frame = s->iv_frame;
-         s->ref_frame = s->iv_frame + 1;
+     ctx->frame_num   =  frame_num;
+     ctx->frame_flags =  bytestream_get_le16(&buf_ptr);
+     ctx->data_size   = (bytestream_get_le32(&buf_ptr) + 7) >> 3;
+     ctx->cb_offset   = *buf_ptr++;
+     if (ctx->data_size == 16)
+         return 4;
+     if (ctx->data_size > buf_size)
+         ctx->data_size = buf_size;
+     buf_ptr += 3; // skip reserved byte and checksum
+     /* check frame dimensions */
+     height = bytestream_get_le16(&buf_ptr);
+     width  = bytestream_get_le16(&buf_ptr);
+     if (av_image_check_size(width, height, 0, avctx))
+         return AVERROR_INVALIDDATA;
+     if (width != ctx->width || height != ctx->height) {
+         av_dlog(avctx, "Frame dimensions changed!\n");
+         ctx->width  = width;
+         ctx->height = height;
+         free_frame_buffers(ctx);
+         allocate_frame_buffers(ctx, avctx);
+         avcodec_set_dimensions(avctx, width, height);
+     }
+     y_offset = bytestream_get_le32(&buf_ptr);
+     v_offset = bytestream_get_le32(&buf_ptr);
+     u_offset = bytestream_get_le32(&buf_ptr);
+     /* unfortunately there is no common order of planes in the buffer */
+     /* so we use that sorting algo for determining planes data sizes  */
+     starts[0] = y_offset;
+     starts[1] = v_offset;
+     starts[2] = u_offset;
+     for (j = 0; j < 3; j++) {
+         ends[j] = ctx->data_size;
+         for (i = 2; i >= 0; i--)
+             if (starts[i] < ends[j] && starts[i] > starts[j])
+                 ends[j] = starts[i];
      }
  
-     buf_pos = buf + 16 + y_offset;
-     mc_vector_count = bytestream_get_le32(&buf_pos);
-     if(2LL*mc_vector_count >= buf_size-16-y_offset) {
-         av_log(s->avctx, AV_LOG_ERROR, "mc_vector_count too large\n");
-         return -1;
+     ctx->y_data_size = ends[0] - starts[0];
+     ctx->v_data_size = ends[1] - starts[1];
+     ctx->u_data_size = ends[2] - starts[2];
+     if (FFMAX3(y_offset, v_offset, u_offset) >= ctx->data_size - 16 ||
+         FFMIN3(ctx->y_data_size, ctx->v_data_size, ctx->u_data_size) <= 0) {
+         av_log(avctx, AV_LOG_ERROR, "One of the y/u/v offsets is invalid\n");
+         return AVERROR_INVALIDDATA;
      }
  
-     iv_Decode_Chunk(s, s->cur_frame->Ybuf, s->ref_frame->Ybuf, image_width,
-                     image_height, buf_pos + mc_vector_count * 2, cb_offset, hdr_pos, buf_pos,
-                     FFMIN(image_width, 160));
+     ctx->y_data_ptr = bs_hdr + y_offset;
+     ctx->v_data_ptr = bs_hdr + v_offset;
+     ctx->u_data_ptr = bs_hdr + u_offset;
+     ctx->alt_quant  = buf_ptr + sizeof(uint32_t);
  
-     if (!(s->avctx->flags & CODEC_FLAG_GRAY))
-     {
+     if (ctx->data_size == 16) {
+         av_log(avctx, AV_LOG_DEBUG, "Sync frame encountered!\n");
+         return 16;
+     }
  
-         buf_pos = buf + 16 + v_offset;
-         mc_vector_count = bytestream_get_le32(&buf_pos);
-         if(2LL*mc_vector_count >= buf_size-16-v_offset) {
-             av_log(s->avctx, AV_LOG_ERROR, "mc_vector_count too large\n");
-             return -1;
-         }
+     if (ctx->frame_flags & BS_8BIT_PEL) {
+         av_log_ask_for_sample(avctx, "8-bit pixel format\n");
+         return AVERROR_PATCHWELCOME;
+     }
+     if (ctx->frame_flags & BS_MV_X_HALF || ctx->frame_flags & BS_MV_Y_HALF) {
+         av_log_ask_for_sample(avctx, "halfpel motion vectors\n");
+         return AVERROR_PATCHWELCOME;
+     }
+     return 0;
+ }
  
-         iv_Decode_Chunk(s, s->cur_frame->Vbuf, s->ref_frame->Vbuf, chroma_width,
-                 chroma_height, buf_pos + mc_vector_count * 2, cb_offset, hdr_pos, buf_pos,
-                 FFMIN(chroma_width, 40));
  
-         buf_pos = buf + 16 + u_offset;
-         mc_vector_count = bytestream_get_le32(&buf_pos);
-         if(2LL*mc_vector_count >= buf_size-16-u_offset) {
-             av_log(s->avctx, AV_LOG_ERROR, "mc_vector_count too large\n");
-             return -1;
+ /**
+  *  Convert and output the current plane.
+  *  All pixel values will be upsampled by shifting right by one bit.
+  *
+  *  @param[in]  plane        pointer to the descriptor of the plane being processed
+  *  @param[in]  buf_sel      indicates which frame buffer the input data stored in
+  *  @param[out] dst          pointer to the buffer receiving converted pixels
+  *  @param[in]  dst_pitch    pitch for moving to the next y line
+  */
+ static void output_plane(const Plane *plane, int buf_sel, uint8_t *dst, int dst_pitch)
+ {
+     int             x,y;
+     const uint8_t   *src  = plane->pixels[buf_sel];
+     uint32_t        pitch = plane->pitch;
+     for (y = 0; y < plane->height; y++) {
+         /* convert four pixels at once using SWAR */
+         for (x = 0; x < plane->width >> 2; x++) {
+             AV_WN32A(dst, (AV_RN32A(src) & 0x7F7F7F7F) << 1);
+             src += 4;
+             dst += 4;
          }
  
-         iv_Decode_Chunk(s, s->cur_frame->Ubuf, s->ref_frame->Ubuf, chroma_width,
-                 chroma_height, buf_pos + mc_vector_count * 2, cb_offset, hdr_pos, buf_pos,
-                 FFMIN(chroma_width, 40));
+         for (x <<= 2; x < plane->width; x++)
+             *dst++ = *src++ << 1;
  
+         src += pitch     - plane->width;
+         dst += dst_pitch - plane->width;
      }
+ }
+ static av_cold int decode_init(AVCodecContext *avctx)
+ {
+     Indeo3DecodeContext *ctx = avctx->priv_data;
+     ctx->avctx     = avctx;
+     ctx->width     = avctx->width;
+     ctx->height    = avctx->height;
+     avctx->pix_fmt = PIX_FMT_YUV410P;
++    avcodec_get_frame_defaults(&ctx->frame);
+     build_requant_tab();
+     dsputil_init(&ctx->dsp, avctx);
  
-     return 8;
+     allocate_frame_buffers(ctx, avctx);
+     return 0;
  }
  
- static int indeo3_decode_frame(AVCodecContext *avctx,
                               void *data, int *data_size,
-                                AVPacket *avpkt)
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
+                         AVPacket *avpkt)
  {
+     Indeo3DecodeContext *ctx = avctx->priv_data;
      const uint8_t *buf = avpkt->data;
-     int buf_size = avpkt->size;
-     Indeo3DecodeContext *s=avctx->priv_data;
-     uint8_t *src, *dest;
-     int y;
+     int buf_size       = avpkt->size;
+     int res;
+     res = decode_frame_headers(ctx, avctx, buf, buf_size);
+     if (res < 0)
+         return res;
+     /* skip sync(null) frames */
+     if (res) {
+         // we have processed 16 bytes but no data was decoded
+         *data_size = 0;
+         return buf_size;
+     }
  
-     if (iv_decode_frame(avctx, buf, buf_size) < 0)
-         return -1;
+     /* skip droppable INTER frames if requested */
+     if (ctx->frame_flags & BS_NONREF &&
+        (avctx->skip_frame >= AVDISCARD_NONREF))
+         return 0;
  
-     if(s->frame.data[0])
-         avctx->release_buffer(avctx, &s->frame);
+     /* skip INTER frames if requested */
+     if (!(ctx->frame_flags & BS_KEYFRAME) && avctx->skip_frame >= AVDISCARD_NONKEY)
+         return 0;
  
-     s->frame.reference = 0;
-     if(avctx->get_buffer(avctx, &s->frame) < 0) {
-         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-         return -1;
-     }
+     /* use BS_BUFFER flag for buffer switching */
+     ctx->buf_sel = (ctx->frame_flags >> BS_BUFFER) & 1;
  
-     src = s->cur_frame->Ybuf;
-     dest = s->frame.data[0];
-     for (y = 0; y < s->height; y++) {
-         memcpy(dest, src, s->cur_frame->y_w);
-         src += s->cur_frame->y_w;
-         dest += s->frame.linesize[0];
-     }
+     /* decode luma plane */
+     if ((res = decode_plane(ctx, avctx, ctx->planes, ctx->y_data_ptr, ctx->y_data_size, 40)))
+         return res;
  
-     if (!(s->avctx->flags & CODEC_FLAG_GRAY))
-     {
-         src = s->cur_frame->Ubuf;
-         dest = s->frame.data[1];
-         for (y = 0; y < s->height / 4; y++) {
-             memcpy(dest, src, s->cur_frame->uv_w);
-             src += s->cur_frame->uv_w;
-             dest += s->frame.linesize[1];
-         }
+     /* decode chroma planes */
+     if ((res = decode_plane(ctx, avctx, &ctx->planes[1], ctx->u_data_ptr, ctx->u_data_size, 10)))
+         return res;
  
-         src = s->cur_frame->Vbuf;
-         dest = s->frame.data[2];
-         for (y = 0; y < s->height / 4; y++) {
-             memcpy(dest, src, s->cur_frame->uv_w);
-             src += s->cur_frame->uv_w;
-             dest += s->frame.linesize[2];
-         }
+     if ((res = decode_plane(ctx, avctx, &ctx->planes[2], ctx->v_data_ptr, ctx->v_data_size, 10)))
+         return res;
+     if (ctx->frame.data[0])
+         avctx->release_buffer(avctx, &ctx->frame);
+     ctx->frame.reference = 0;
+     if ((res = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
+         av_log(ctx->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+         return res;
      }
  
-     *data_size=sizeof(AVFrame);
-     *(AVFrame*)data= s->frame;
+     output_plane(&ctx->planes[0], ctx->buf_sel, ctx->frame.data[0], ctx->frame.linesize[0]);
+     output_plane(&ctx->planes[1], ctx->buf_sel, ctx->frame.data[1], ctx->frame.linesize[1]);
+     output_plane(&ctx->planes[2], ctx->buf_sel, ctx->frame.data[2], ctx->frame.linesize[2]);
+     *data_size      = sizeof(AVFrame);
+     *(AVFrame*)data = ctx->frame;
  
      return buf_size;
  }
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * Intel Indeo 3 (IV31, IV32, etc.) video decoder for ffmpeg
-  * written, produced, and directed by Alan Smithee
+  * Indeo Video v3 compatible decoder
+  * Copyright (c) 2009 - 2011 Maxim Poliakovski
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -127,9 -97,8 +127,8 @@@ static int jpeg_parse(AVCodecParserCont
  
  
  AVCodecParser ff_mjpeg_parser = {
-     { CODEC_ID_MJPEG },
-     sizeof(MJPEGParserContext),
-     NULL,
-     jpeg_parse,
-     ff_parse_close,
+     .codec_ids      = { CODEC_ID_MJPEG },
 -    .priv_data_size = sizeof(ParseContext),
++    .priv_data_size = sizeof(MJPEGParserContext),
+     .parser_parse   = jpeg_parse,
+     .parser_close   = ff_parse_close,
  };
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * MSMPEG4 backend for ffmpeg encoder and decoder
+  * MSMPEG4 backend for encoder and decoder
   * copyright (c) 2007 Aurelien Jacobs <aurel@gnuage.org>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -2,13 -2,13 +2,13 @@@
   * Duck Truemotion v1 Decoding Tables
   *
   * Data in this file was originally part of VpVision from On2 which is
-  * distributed under the GNU GPL. It is redistributed with ffmpeg under the
-  * GNU LGPL using the common understanding that data tables necessary for
-  * decoding algorithms are not necessarily licensable.
+  * distributed under the GNU GPL. It is redistributed with libavcodec under
+  * the GNU LGPL using the common understanding that data tables necessary
+  * for decoding algorithms are not necessarily copyrightable.
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
Simple merge
@@@ -2000,11 -1993,6 +1994,8 @@@ error
      return -1;
  }
  
- /*
-  * This is the ffmpeg/libavcodec API module cleanup function.
-  */
 +static void vp3_decode_flush(AVCodecContext *avctx);
 +
  static av_cold int vp3_decode_end(AVCodecContext *avctx)
  {
      Vp3DecodeContext *s = avctx->priv_data;
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * Unbuffered io for ffmpeg system
+  * unbuffered I/O
   * Copyright (c) 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * Buffered I/O for ffmpeg system
+  * buffered I/O
   * Copyright (c) 2000,2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * AVISynth support for ffmpeg system
+  * AVISynth support
   * Copyright (c) 2006 DivX, Inc.
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * Various simple utilities for ffmpeg system
+  * various simple utilities for libavformat
   * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
Simple merge
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * Buffered file io for ffmpeg system
+  * buffered file I/O
   * Copyright (c) 2001 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
@@@ -439,15 -417,16 +441,20 @@@ static int flv_write_packet(AVFormatCon
              if (ff_avc_parse_nal_units_buf(pkt->data, &data, &size) < 0)
                  return -1;
          }
 +    } else if (enc->codec_id == CODEC_ID_AAC && pkt->size > 2 &&
 +               (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
 +        av_log(s, AV_LOG_ERROR, "malformated aac bitstream, use -absf aac_adtstoasc\n");
 +        return -1;
      }
-     if (!sc->delay && pkt->dts < 0)
-         sc->delay = -pkt->dts;
+     if (flv->delay == AV_NOPTS_VALUE)
+         flv->delay = -pkt->dts;
+     if (pkt->dts < -flv->delay) {
+         av_log(s, AV_LOG_WARNING, "Packets are not in the proper order with "
+                                   "respect to DTS\n");
+         return AVERROR(EINVAL);
+     }
  
-     ts = pkt->dts + sc->delay; // add delay to force positive dts
+     ts = pkt->dts + flv->delay; // add delay to force positive dts
  
      /* check Speex packet duration */
      if (enc->codec_id == CODEC_ID_SPEEX && ts - sc->last_ts > 160) {
Simple merge
Simple merge
Simple merge
@@@ -1,10 -1,10 +1,10 @@@
  /*
-  * various utilities for ffmpeg system
+  * various OS-feature replacement utilities
   * copyright (c) 2000, 2001, 2002 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc libavutil/log.c
Simple merge
@@@ -401,19 -401,7 +401,17 @@@ static int date_get_num(const char **pp
      return val;
  }
  
- static
- const char *small_strptime(const char *p, const char *fmt,
-                            struct tm *dt)
 +/**
 + * Parse the input string p according to the format string fmt and
 + * store its results in the structure dt.
 + * This implementation supports only a subset of the formats supported
 + * by the standard strptime().
 + *
 + * @return a pointer to the first character not processed in this
 + * function call, or NULL in case the function fails to match all of
 + * the fmt string and therefore an error occurred
 + */
+ static const char *small_strptime(const char *p, const char *fmt, struct tm *dt)
  {
      int c, val;