git.sesse.net Git - ffmpeg/blob - libavcodec/svq3.c

   1 /*
   2  * Copyright (c) 2003 The FFmpeg Project
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /*
  22  * How to use this decoder:
  23  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
  24  * have stsd atoms to describe media trak properties. A stsd atom for a
  25  * video trak contains 1 or more ImageDescription atoms. These atoms begin
  26  * with the 4-byte length of the atom followed by the codec fourcc. Some
  27  * decoders need information in this atom to operate correctly. Such
  28  * is the case with SVQ3. In order to get the best use out of this decoder,
  29  * the calling app must make the SVQ3 ImageDescription atom available
  30  * via the AVCodecContext's extradata[_size] field:
  31  *
  32  * AVCodecContext.extradata = pointer to ImageDescription, first characters
  33  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
  34  * AVCodecContext.extradata_size = size of ImageDescription atom memory
  35  * buffer (which will be the same as the ImageDescription atom size field
  36  * from the QT file, minus 4 bytes since the length is missing)
  37  *
  38  * You will know you have these parameters passed correctly when the decoder
  39  * correctly decodes this file:
  40  *  http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
  41  */
  42
  43 #include <inttypes.h>
  44
  45 #include "libavutil/attributes.h"
  46 #include "internal.h"
  47 #include "avcodec.h"
  48 #include "mpegutils.h"
  49 #include "h264.h"
  50
  51 #include "h264data.h" // FIXME FIXME FIXME
  52
  53 #include "h264_mvpred.h"
  54 #include "golomb.h"
  55 #include "hpeldsp.h"
  56 #include "rectangle.h"
  57 #include "tpeldsp.h"
  58 #include "vdpau_internal.h"
  59
  60 #if CONFIG_ZLIB
  61 #include <zlib.h>
  62 #endif
  63
  64 #include "svq1.h"
  65 #include "svq3.h"
  66
  67 /**
  68  * @file
  69  * svq3 decoder.
  70  */
  71
  72 typedef struct SVQ3Context {
  73     H264Context h;
  74     HpelDSPContext hdsp;
  75     TpelDSPContext tdsp;
  76     H264Picture *cur_pic;
  77     H264Picture *next_pic;
  78     H264Picture *last_pic;
  79     int halfpel_flag;
  80     int thirdpel_flag;
  81     int unknown_flag;
  82     int next_slice_index;
  83     uint32_t watermark_key;
  84     uint8_t *buf;
  85     int buf_size;
  86     int adaptive_quant;
  87     int next_p_frame_damaged;
  88     int h_edge_pos;
  89     int v_edge_pos;
  90     int last_frame_output;
  91 } SVQ3Context;
  92
  93 #define FULLPEL_MODE  1
  94 #define HALFPEL_MODE  2
  95 #define THIRDPEL_MODE 3
  96 #define PREDICT_MODE  4
  97
  98 /* dual scan (from some older h264 draft)
  99  * o-->o-->o   o
 100  *         |  /|
 101  * o   o   o / o
 102  * | / |   |/  |
 103  * o   o   o   o
 104  *   /
 105  * o-->o-->o-->o
 106  */
 107 static const uint8_t svq3_scan[16] = {
 108     0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
 109     2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
 110     0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
 111     0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
 112 };
 113
 114 static const uint8_t luma_dc_zigzag_scan[16] = {
 115     0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
 116     3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
 117     1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
 118     3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
 119 };
 120
 121 static const uint8_t svq3_pred_0[25][2] = {
 122     { 0, 0 },
 123     { 1, 0 }, { 0, 1 },
 124     { 0, 2 }, { 1, 1 }, { 2, 0 },
 125     { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
 126     { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
 127     { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
 128     { 2, 4 }, { 3, 3 }, { 4, 2 },
 129     { 4, 3 }, { 3, 4 },
 130     { 4, 4 }
 131 };
 132
 133 static const int8_t svq3_pred_1[6][6][5] = {
 134     { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
 135       { 2,  1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
 136     { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  4,  3 }, { 0, 1,  2,  4,  3 },
 137       { 0,  2,  1,  4,  3 }, { 2, 0,  1,  3,  4 }, { 0, 4,  2,  1,  3 } },
 138     { { 2,  0, -1, -1, -1 }, { 2, 1,  0,  4,  3 }, { 1, 2,  4,  0,  3 },
 139       { 2,  1,  0,  4,  3 }, { 2, 1,  4,  3,  0 }, { 1, 2,  4,  0,  3 } },
 140     { { 2,  0, -1, -1, -1 }, { 2, 0,  1,  4,  3 }, { 1, 2,  0,  4,  3 },
 141       { 2,  1,  0,  4,  3 }, { 2, 1,  3,  4,  0 }, { 2, 4,  1,  0,  3 } },
 142     { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  3,  4 }, { 1, 2,  3,  0,  4 },
 143       { 2,  0,  1,  3,  4 }, { 2, 1,  3,  0,  4 }, { 2, 0,  4,  3,  1 } },
 144     { { 0,  2, -1, -1, -1 }, { 0, 2,  4,  1,  3 }, { 1, 4,  2,  0,  3 },
 145       { 4,  2,  0,  1,  3 }, { 2, 0,  1,  4,  3 }, { 4, 2,  1,  0,  3 } },
 146 };
 147
 148 static const struct {
 149     uint8_t run;
 150     uint8_t level;
 151 } svq3_dct_tables[2][16] = {
 152     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
 153       { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
 154     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
 155       { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
 156 };
 157
 158 static const uint32_t svq3_dequant_coeff[32] = {
 159      3881,  4351,  4890,  5481,   6154,   6914,   7761,   8718,
 160      9781, 10987, 12339, 13828,  15523,  17435,  19561,  21873,
 161     24552, 27656, 30847, 34870,  38807,  43747,  49103,  54683,
 162     61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
 163 };
 164
 165 static int svq3_decode_end(AVCodecContext *avctx);
 166
 167 void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
 168 {
 169     const int qmul = svq3_dequant_coeff[qp];
 170 #define stride 16
 171     int i;
 172     int temp[16];
 173     static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
 174
 175     for (i = 0; i < 4; i++) {
 176         const int z0 = 13 * (input[4 * i + 0] +      input[4 * i + 2]);
 177         const int z1 = 13 * (input[4 * i + 0] -      input[4 * i + 2]);
 178         const int z2 =  7 *  input[4 * i + 1] - 17 * input[4 * i + 3];
 179         const int z3 = 17 *  input[4 * i + 1] +  7 * input[4 * i + 3];
 180
 181         temp[4 * i + 0] = z0 + z3;
 182         temp[4 * i + 1] = z1 + z2;
 183         temp[4 * i + 2] = z1 - z2;
 184         temp[4 * i + 3] = z0 - z3;
 185     }
 186
 187     for (i = 0; i < 4; i++) {
 188         const int offset = x_offset[i];
 189         const int z0     = 13 * (temp[4 * 0 + i] +      temp[4 * 2 + i]);
 190         const int z1     = 13 * (temp[4 * 0 + i] -      temp[4 * 2 + i]);
 191         const int z2     =  7 *  temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
 192         const int z3     = 17 *  temp[4 * 1 + i] +  7 * temp[4 * 3 + i];
 193
 194         output[stride *  0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
 195         output[stride *  2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
 196         output[stride *  8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
 197         output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
 198     }
 199 }
 200 #undef stride
 201
 202 void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
 203                         int stride, int qp, int dc)
 204 {
 205     const int qmul = svq3_dequant_coeff[qp];
 206     int i;
 207
 208     if (dc) {
 209         dc       = 13 * 13 * (dc == 1 ? 1538 * block[0]
 210                                       : qmul * (block[0] >> 3) / 2);
 211         block[0] = 0;
 212     }
 213
 214     for (i = 0; i < 4; i++) {
 215         const int z0 = 13 * (block[0 + 4 * i] +      block[2 + 4 * i]);
 216         const int z1 = 13 * (block[0 + 4 * i] -      block[2 + 4 * i]);
 217         const int z2 =  7 *  block[1 + 4 * i] - 17 * block[3 + 4 * i];
 218         const int z3 = 17 *  block[1 + 4 * i] +  7 * block[3 + 4 * i];
 219
 220         block[0 + 4 * i] = z0 + z3;
 221         block[1 + 4 * i] = z1 + z2;
 222         block[2 + 4 * i] = z1 - z2;
 223         block[3 + 4 * i] = z0 - z3;
 224     }
 225
 226     for (i = 0; i < 4; i++) {
 227         const int z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
 228         const int z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
 229         const int z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
 230         const int z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
 231         const int rr = (dc + 0x80000);
 232
 233         dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
 234         dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
 235         dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
 236         dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
 237     }
 238
 239     memset(block, 0, 16 * sizeof(int16_t));
 240 }
 241
 242 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
 243                                     int index, const int type)
 244 {
 245     static const uint8_t *const scan_patterns[4] =
 246     { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
 247
 248     int run, level, sign, limit;
 249     unsigned vlc;
 250     const int intra           = 3 * type >> 2;
 251     const uint8_t *const scan = scan_patterns[type];
 252
 253     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
 254         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
 255             if ((int32_t)vlc < 0)
 256                 return -1;
 257
 258             sign     = (vlc & 1) ? 0 : -1;
 259             vlc      = vlc + 1 >> 1;
 260
 261             if (type == 3) {
 262                 if (vlc < 3) {
 263                     run   = 0;
 264                     level = vlc;
 265                 } else if (vlc < 4) {
 266                     run   = 1;
 267                     level = 1;
 268                 } else {
 269                     run   = vlc & 0x3;
 270                     level = (vlc + 9 >> 2) - run;
 271                 }
 272             } else {
 273                 if (vlc < 16U) {
 274                     run   = svq3_dct_tables[intra][vlc].run;
 275                     level = svq3_dct_tables[intra][vlc].level;
 276                 } else if (intra) {
 277                     run   = vlc & 0x7;
 278                     level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 279                 } else {
 280                     run   = vlc & 0xF;
 281                     level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 282                 }
 283             }
 284
 285
 286             if ((index += run) >= limit)
 287                 return -1;
 288
 289             block[scan[index]] = (level ^ sign) - sign;
 290         }
 291
 292         if (type != 2) {
 293             break;
 294         }
 295     }
 296
 297     return 0;
 298 }
 299
 300 static inline void svq3_mc_dir_part(SVQ3Context *s,
 301                                     int x, int y, int width, int height,
 302                                     int mx, int my, int dxy,
 303                                     int thirdpel, int dir, int avg)
 304 {
 305     H264Context *h = &s->h;
 306     const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
 307     uint8_t *src, *dest;
 308     int i, emu = 0;
 309     int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
 310
 311     mx += x;
 312     my += y;
 313
 314     if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
 315         my < 0 || my >= s->v_edge_pos - height - 1) {
 316         emu = 1;
 317         mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
 318         my = av_clip(my, -16, s->v_edge_pos - height + 15);
 319     }
 320
 321     /* form component predictions */
 322     dest = h->cur_pic.f.data[0] + x + y * h->linesize;
 323     src  = pic->f.data[0] + mx + my * h->linesize;
 324
 325     if (emu) {
 326         h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src,
 327                                  h->linesize, h->linesize,
 328                                  width + 1, height + 1,
 329                                  mx, my, s->h_edge_pos, s->v_edge_pos);
 330         src = h->edge_emu_buffer;
 331     }
 332     if (thirdpel)
 333         (avg ? s->tdsp.avg_tpel_pixels_tab
 334              : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, h->linesize,
 335                                                  width, height);
 336     else
 337         (avg ? s->hdsp.avg_pixels_tab
 338              : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, h->linesize,
 339                                                        height);
 340
 341     if (!(h->flags & CODEC_FLAG_GRAY)) {
 342         mx     = mx + (mx < (int) x) >> 1;
 343         my     = my + (my < (int) y) >> 1;
 344         width  = width  >> 1;
 345         height = height >> 1;
 346         blocksize++;
 347
 348         for (i = 1; i < 3; i++) {
 349             dest = h->cur_pic.f.data[i] + (x >> 1) + (y >> 1) * h->uvlinesize;
 350             src  = pic->f.data[i] + mx + my * h->uvlinesize;
 351
 352             if (emu) {
 353                 h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src,
 354                                          h->uvlinesize, h->uvlinesize,
 355                                          width + 1, height + 1,
 356                                          mx, my, (s->h_edge_pos >> 1),
 357                                          s->v_edge_pos >> 1);
 358                 src = h->edge_emu_buffer;
 359             }
 360             if (thirdpel)
 361                 (avg ? s->tdsp.avg_tpel_pixels_tab
 362                      : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
 363                                                          h->uvlinesize,
 364                                                          width, height);
 365             else
 366                 (avg ? s->hdsp.avg_pixels_tab
 367                      : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
 368                                                                h->uvlinesize,
 369                                                                height);
 370         }
 371     }
 372 }
 373
 374 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
 375                               int dir, int avg)
 376 {
 377     int i, j, k, mx, my, dx, dy, x, y;
 378     H264Context *h          = &s->h;
 379     H264SliceContext *sl    = &h->slice_ctx[0];
 380     const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 381     const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
 382     const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
 383     const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
 384     const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;
 385
 386     for (i = 0; i < 16; i += part_height)
 387         for (j = 0; j < 16; j += part_width) {
 388             const int b_xy = (4 * h->mb_x + (j >> 2)) +
 389                              (4 * h->mb_y + (i >> 2)) * h->b_stride;
 390             int dxy;
 391             x = 16 * h->mb_x + j;
 392             y = 16 * h->mb_y + i;
 393             k = (j >> 2 & 1) + (i >> 1 & 2) +
 394                 (j >> 1 & 4) + (i      & 8);
 395
 396             if (mode != PREDICT_MODE) {
 397                 pred_motion(h, sl, k, part_width >> 2, dir, 1, &mx, &my);
 398             } else {
 399                 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
 400                 my = s->next_pic->motion_val[0][b_xy][1] << 1;
 401
 402                 if (dir == 0) {
 403                     mx = mx * h->frame_num_offset /
 404                          h->prev_frame_num_offset + 1 >> 1;
 405                     my = my * h->frame_num_offset /
 406                          h->prev_frame_num_offset + 1 >> 1;
 407                 } else {
 408                     mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
 409                          h->prev_frame_num_offset + 1 >> 1;
 410                     my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
 411                          h->prev_frame_num_offset + 1 >> 1;
 412                 }
 413             }
 414
 415             /* clip motion vector prediction to frame border */
 416             mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
 417             my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
 418
 419             /* get (optional) motion vector differential */
 420             if (mode == PREDICT_MODE) {
 421                 dx = dy = 0;
 422             } else {
 423                 dy = svq3_get_se_golomb(&h->gb);
 424                 dx = svq3_get_se_golomb(&h->gb);
 425
 426                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 427                     av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 428                     return -1;
 429                 }
 430             }
 431
 432             /* compute motion vector */
 433             if (mode == THIRDPEL_MODE) {
 434                 int fx, fy;
 435                 mx  = (mx + 1 >> 1) + dx;
 436                 my  = (my + 1 >> 1) + dy;
 437                 fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
 438                 fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
 439                 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
 440
 441                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 442                                  fx, fy, dxy, 1, dir, avg);
 443                 mx += mx;
 444                 my += my;
 445             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 446                 mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
 447                 my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
 448                 dxy = (mx & 1) + 2 * (my & 1);
 449
 450                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 451                                  mx >> 1, my >> 1, dxy, 0, dir, avg);
 452                 mx *= 3;
 453                 my *= 3;
 454             } else {
 455                 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
 456                 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
 457
 458                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 459                                  mx, my, 0, 0, dir, avg);
 460                 mx *= 6;
 461                 my *= 6;
 462             }
 463
 464             /* update mv_cache */
 465             if (mode != PREDICT_MODE) {
 466                 int32_t mv = pack16to32(mx, my);
 467
 468                 if (part_height == 8 && i < 8) {
 469                     AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 * 8], mv);
 470
 471                     if (part_width == 8 && j < 8)
 472                         AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
 473                 }
 474                 if (part_width == 8 && j < 8)
 475                     AV_WN32A(sl->mv_cache[dir][scan8[k] + 1], mv);
 476                 if (part_width == 4 || part_height == 4)
 477                     AV_WN32A(sl->mv_cache[dir][scan8[k]], mv);
 478             }
 479
 480             /* write back motion vectors */
 481             fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
 482                            part_width >> 2, part_height >> 2, h->b_stride,
 483                            pack16to32(mx, my), 4);
 484         }
 485
 486     return 0;
 487 }
 488
 489 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
 490 {
 491     H264Context *h = &s->h;
 492     H264SliceContext *sl = &h->slice_ctx[0];
 493     int i, j, k, m, dir, mode;
 494     int cbp = 0;
 495     uint32_t vlc;
 496     int8_t *top, *left;
 497     const int mb_xy         = h->mb_xy;
 498     const int b_xy          = 4 * h->mb_x + 4 * h->mb_y * h->b_stride;
 499
 500     sl->top_samples_available      = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
 501     sl->left_samples_available     = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
 502     sl->topright_samples_available = 0xFFFF;
 503
 504     if (mb_type == 0) {           /* SKIP */
 505         if (h->pict_type == AV_PICTURE_TYPE_P ||
 506             s->next_pic->mb_type[mb_xy] == -1) {
 507             svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
 508                              0, 0, 0, 0, 0, 0);
 509
 510             if (h->pict_type == AV_PICTURE_TYPE_B)
 511                 svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
 512                                  0, 0, 0, 0, 1, 1);
 513
 514             mb_type = MB_TYPE_SKIP;
 515         } else {
 516             mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
 517             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
 518                 return -1;
 519             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
 520                 return -1;
 521
 522             mb_type = MB_TYPE_16x16;
 523         }
 524     } else if (mb_type < 8) {     /* INTER */
 525         if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
 526             mode = THIRDPEL_MODE;
 527         else if (s->halfpel_flag &&
 528                  s->thirdpel_flag == !get_bits1(&h->gb))
 529             mode = HALFPEL_MODE;
 530         else
 531             mode = FULLPEL_MODE;
 532
 533         /* fill caches */
 534         /* note ref_cache should contain here:
 535          *  ????????
 536          *  ???11111
 537          *  N??11111
 538          *  N??11111
 539          *  N??11111
 540          */
 541
 542         for (m = 0; m < 2; m++) {
 543             if (h->mb_x > 0 && sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
 544                 for (i = 0; i < 4; i++)
 545                     AV_COPY32(sl->mv_cache[m][scan8[0] - 1 + i * 8],
 546                               h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
 547             } else {
 548                 for (i = 0; i < 4; i++)
 549                     AV_ZERO32(sl->mv_cache[m][scan8[0] - 1 + i * 8]);
 550             }
 551             if (h->mb_y > 0) {
 552                 memcpy(sl->mv_cache[m][scan8[0] - 1 * 8],
 553                        h->cur_pic.motion_val[m][b_xy - h->b_stride],
 554                        4 * 2 * sizeof(int16_t));
 555                 memset(&sl->ref_cache[m][scan8[0] - 1 * 8],
 556                        (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 557
 558                 if (h->mb_x < h->mb_width - 1) {
 559                     AV_COPY32(sl->mv_cache[m][scan8[0] + 4 - 1 * 8],
 560                               h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
 561                     sl->ref_cache[m][scan8[0] + 4 - 1 * 8] =
 562                         (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
 563                          sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
 564                 } else
 565                     sl->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
 566                 if (h->mb_x > 0) {
 567                     AV_COPY32(sl->mv_cache[m][scan8[0] - 1 - 1 * 8],
 568                               h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
 569                     sl->ref_cache[m][scan8[0] - 1 - 1 * 8] =
 570                         (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
 571                 } else
 572                     sl->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
 573             } else
 574                 memset(&sl->ref_cache[m][scan8[0] - 1 * 8 - 1],
 575                        PART_NOT_AVAILABLE, 8);
 576
 577             if (h->pict_type != AV_PICTURE_TYPE_B)
 578                 break;
 579         }
 580
 581         /* decode motion vector(s) and form prediction(s) */
 582         if (h->pict_type == AV_PICTURE_TYPE_P) {
 583             if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
 584                 return -1;
 585         } else {        /* AV_PICTURE_TYPE_B */
 586             if (mb_type != 2) {
 587                 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
 588                     return -1;
 589             } else {
 590                 for (i = 0; i < 4; i++)
 591                     memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
 592                            0, 4 * 2 * sizeof(int16_t));
 593             }
 594             if (mb_type != 1) {
 595                 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
 596                     return -1;
 597             } else {
 598                 for (i = 0; i < 4; i++)
 599                     memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
 600                            0, 4 * 2 * sizeof(int16_t));
 601             }
 602         }
 603
 604         mb_type = MB_TYPE_16x16;
 605     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 606         memset(sl->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
 607
 608         if (mb_type == 8) {
 609             if (h->mb_x > 0) {
 610                 for (i = 0; i < 4; i++)
 611                     sl->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
 612                 if (sl->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
 613                     sl->left_samples_available = 0x5F5F;
 614             }
 615             if (h->mb_y > 0) {
 616                 sl->intra4x4_pred_mode_cache[4 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
 617                 sl->intra4x4_pred_mode_cache[5 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
 618                 sl->intra4x4_pred_mode_cache[6 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
 619                 sl->intra4x4_pred_mode_cache[7 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
 620
 621                 if (sl->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
 622                     sl->top_samples_available = 0x33FF;
 623             }
 624
 625             /* decode prediction codes for luma blocks */
 626             for (i = 0; i < 16; i += 2) {
 627                 vlc = svq3_get_ue_golomb(&h->gb);
 628
 629                 if (vlc >= 25U) {
 630                     av_log(h->avctx, AV_LOG_ERROR,
 631                            "luma prediction:%"PRIu32"\n", vlc);
 632                     return -1;
 633                 }
 634
 635                 left = &sl->intra4x4_pred_mode_cache[scan8[i] - 1];
 636                 top  = &sl->intra4x4_pred_mode_cache[scan8[i] - 8];
 637
 638                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 639                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 640
 641                 if (left[1] == -1 || left[2] == -1) {
 642                     av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
 643                     return -1;
 644                 }
 645             }
 646         } else {    /* mb_type == 33, DC_128_PRED block type */
 647             for (i = 0; i < 4; i++)
 648                 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
 649         }
 650
 651         write_back_intra_pred_mode(h, sl);
 652
 653         if (mb_type == 8) {
 654             ff_h264_check_intra4x4_pred_mode(h, sl);
 655
 656             sl->top_samples_available  = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
 657             sl->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
 658         } else {
 659             for (i = 0; i < 4; i++)
 660                 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
 661
 662             sl->top_samples_available  = 0x33FF;
 663             sl->left_samples_available = 0x5F5F;
 664         }
 665
 666         mb_type = MB_TYPE_INTRA4x4;
 667     } else {                      /* INTRA16x16 */
 668         dir = i_mb_type_info[mb_type - 8].pred_mode;
 669         dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
 670
 671         if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
 672             av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
 673             return sl->intra16x16_pred_mode;
 674         }
 675
 676         cbp     = i_mb_type_info[mb_type - 8].cbp;
 677         mb_type = MB_TYPE_INTRA16x16;
 678     }
 679
 680     if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
 681         for (i = 0; i < 4; i++)
 682             memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
 683                    0, 4 * 2 * sizeof(int16_t));
 684         if (h->pict_type == AV_PICTURE_TYPE_B) {
 685             for (i = 0; i < 4; i++)
 686                 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
 687                        0, 4 * 2 * sizeof(int16_t));
 688         }
 689     }
 690     if (!IS_INTRA4x4(mb_type)) {
 691         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
 692     }
 693     if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
 694         memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
 695     }
 696
 697     if (!IS_INTRA16x16(mb_type) &&
 698         (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
 699         if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48U){
 700             av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
 701             return -1;
 702         }
 703
 704         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
 705                                 : golomb_to_inter_cbp[vlc];
 706     }
 707     if (IS_INTRA16x16(mb_type) ||
 708         (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 709         sl->qscale += svq3_get_se_golomb(&h->gb);
 710
 711         if (sl->qscale > 31u) {
 712             av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
 713             return -1;
 714         }
 715     }
 716     if (IS_INTRA16x16(mb_type)) {
 717         AV_ZERO128(h->mb_luma_dc[0] + 0);
 718         AV_ZERO128(h->mb_luma_dc[0] + 8);
 719         if (svq3_decode_block(&h->gb, h->mb_luma_dc[0], 0, 1)) {
 720             av_log(h->avctx, AV_LOG_ERROR,
 721                    "error while decoding intra luma dc\n");
 722             return -1;
 723         }
 724     }
 725
 726     if (cbp) {
 727         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 728         const int type  = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 729
 730         for (i = 0; i < 4; i++)
 731             if ((cbp & (1 << i))) {
 732                 for (j = 0; j < 4; j++) {
 733                     k = index ? (1 * (j & 1) + 2 * (i & 1) +
 734                                  2 * (j & 2) + 4 * (i & 2))
 735                               : (4 * i + j);
 736                     sl->non_zero_count_cache[scan8[k]] = 1;
 737
 738                     if (svq3_decode_block(&h->gb, &h->mb[16 * k], index, type)) {
 739                         av_log(h->avctx, AV_LOG_ERROR,
 740                                "error while decoding block\n");
 741                         return -1;
 742                     }
 743                 }
 744             }
 745
 746         if ((cbp & 0x30)) {
 747             for (i = 1; i < 3; ++i)
 748                 if (svq3_decode_block(&h->gb, &h->mb[16 * 16 * i], 0, 3)) {
 749                     av_log(h->avctx, AV_LOG_ERROR,
 750                            "error while decoding chroma dc block\n");
 751                     return -1;
 752                 }
 753
 754             if ((cbp & 0x20)) {
 755                 for (i = 1; i < 3; i++) {
 756                     for (j = 0; j < 4; j++) {
 757                         k                                 = 16 * i + j;
 758                         sl->non_zero_count_cache[scan8[k]] = 1;
 759
 760                         if (svq3_decode_block(&h->gb, &h->mb[16 * k], 1, 1)) {
 761                             av_log(h->avctx, AV_LOG_ERROR,
 762                                    "error while decoding chroma ac block\n");
 763                             return -1;
 764                         }
 765                     }
 766                 }
 767             }
 768         }
 769     }
 770
 771     h->cbp                              = cbp;
 772     h->cur_pic.mb_type[mb_xy] = mb_type;
 773
 774     if (IS_INTRA(mb_type))
 775         sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, sl, DC_PRED8x8, 1);
 776
 777     return 0;
 778 }
 779
 780 static int svq3_decode_slice_header(AVCodecContext *avctx)
 781 {
 782     SVQ3Context *s = avctx->priv_data;
 783     H264Context *h    = &s->h;
 784     H264SliceContext *sl = &h->slice_ctx[0];
 785     const int mb_xy   = h->mb_xy;
 786     int i, header;
 787     unsigned slice_id;
 788
 789     header = get_bits(&h->gb, 8);
 790
 791     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
 792         /* TODO: what? */
 793         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
 794         return -1;
 795     } else {
 796         int length = header >> 5 & 3;
 797
 798         s->next_slice_index = get_bits_count(&h->gb) +
 799                               8 * show_bits(&h->gb, 8 * length) +
 800                               8 * length;
 801
 802         if (s->next_slice_index > h->gb.size_in_bits) {
 803             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
 804             return -1;
 805         }
 806
 807         h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
 808         skip_bits(&h->gb, 8);
 809
 810         if (s->watermark_key) {
 811             uint32_t header = AV_RL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1]);
 812             AV_WL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1],
 813                     header ^ s->watermark_key);
 814         }
 815         if (length > 0) {
 816             memmove((uint8_t *) &h->gb.buffer[get_bits_count(&h->gb) >> 3],
 817                     &h->gb.buffer[h->gb.size_in_bits >> 3], length - 1);
 818         }
 819         skip_bits_long(&h->gb, 0);
 820     }
 821
 822     if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
 823         av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
 824         return -1;
 825     }
 826
 827     sl->slice_type = golomb_to_pict_type[slice_id];
 828
 829     if ((header & 0x9F) == 2) {
 830         i              = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
 831         h->mb_skip_run = get_bits(&h->gb, i) -
 832                          (h->mb_y * h->mb_width + h->mb_x);
 833     } else {
 834         skip_bits1(&h->gb);
 835         h->mb_skip_run = 0;
 836     }
 837
 838     sl->slice_num     = get_bits(&h->gb, 8);
 839     sl->qscale        = get_bits(&h->gb, 5);
 840     s->adaptive_quant = get_bits1(&h->gb);
 841
 842     /* unknown fields */
 843     skip_bits1(&h->gb);
 844
 845     if (s->unknown_flag)
 846         skip_bits1(&h->gb);
 847
 848     skip_bits1(&h->gb);
 849     skip_bits(&h->gb, 2);
 850
 851     if (skip_1stop_8data_bits(&h->gb) < 0)
 852         return AVERROR_INVALIDDATA;
 853
 854     /* reset intra predictors and invalidate motion vector references */
 855     if (h->mb_x > 0) {
 856         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
 857                -1, 4 * sizeof(int8_t));
 858         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_x],
 859                -1, 8 * sizeof(int8_t) * h->mb_x);
 860     }
 861     if (h->mb_y > 0) {
 862         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
 863                -1, 8 * sizeof(int8_t) * (h->mb_width - h->mb_x));
 864
 865         if (h->mb_x > 0)
 866             sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
 867     }
 868
 869     return 0;
 870 }
 871
 872 static av_cold int svq3_decode_init(AVCodecContext *avctx)
 873 {
 874     SVQ3Context *s = avctx->priv_data;
 875     H264Context *h = &s->h;
 876     int m;
 877     unsigned char *extradata;
 878     unsigned char *extradata_end;
 879     unsigned int size;
 880     int marker_found = 0;
 881     int ret;
 882
 883     s->cur_pic  = av_mallocz(sizeof(*s->cur_pic));
 884     s->last_pic = av_mallocz(sizeof(*s->last_pic));
 885     s->next_pic = av_mallocz(sizeof(*s->next_pic));
 886     if (!s->next_pic || !s->last_pic || !s->cur_pic) {
 887         ret = AVERROR(ENOMEM);
 888         goto fail;
 889     }
 890
 891     if ((ret = ff_h264_decode_init(avctx)) < 0)
 892         goto fail;
 893
 894     ff_hpeldsp_init(&s->hdsp, avctx->flags);
 895     ff_tpeldsp_init(&s->tdsp);
 896
 897     h->flags           = avctx->flags;
 898     h->is_complex      = 1;
 899     h->sps.chroma_format_idc = 1;
 900     h->picture_structure = PICT_FRAME;
 901     avctx->pix_fmt     = AV_PIX_FMT_YUVJ420P;
 902     avctx->color_range = AVCOL_RANGE_JPEG;
 903
 904     h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
 905     h->chroma_x_shift = h->chroma_y_shift = 1;
 906
 907     s->halfpel_flag  = 1;
 908     s->thirdpel_flag = 1;
 909     s->unknown_flag  = 0;
 910
 911     /* prowl for the "SEQH" marker in the extradata */
 912     extradata     = (unsigned char *)avctx->extradata;
 913     extradata_end = avctx->extradata + avctx->extradata_size;
 914     if (extradata) {
 915         for (m = 0; m + 8 < avctx->extradata_size; m++) {
 916             if (!memcmp(extradata, "SEQH", 4)) {
 917                 marker_found = 1;
 918                 break;
 919             }
 920             extradata++;
 921         }
 922     }
 923
 924     /* if a match was found, parse the extra data */
 925     if (marker_found) {
 926         GetBitContext gb;
 927         int frame_size_code;
 928
 929         size = AV_RB32(&extradata[4]);
 930         if (size > extradata_end - extradata - 8) {
 931             ret = AVERROR_INVALIDDATA;
 932             goto fail;
 933         }
 934         init_get_bits(&gb, extradata + 8, size * 8);
 935
 936         /* 'frame size code' and optional 'width, height' */
 937         frame_size_code = get_bits(&gb, 3);
 938         switch (frame_size_code) {
 939         case 0:
 940             avctx->width  = 160;
 941             avctx->height = 120;
 942             break;
 943         case 1:
 944             avctx->width  = 128;
 945             avctx->height =  96;
 946             break;
 947         case 2:
 948             avctx->width  = 176;
 949             avctx->height = 144;
 950             break;
 951         case 3:
 952             avctx->width  = 352;
 953             avctx->height = 288;
 954             break;
 955         case 4:
 956             avctx->width  = 704;
 957             avctx->height = 576;
 958             break;
 959         case 5:
 960             avctx->width  = 240;
 961             avctx->height = 180;
 962             break;
 963         case 6:
 964             avctx->width  = 320;
 965             avctx->height = 240;
 966             break;
 967         case 7:
 968             avctx->width  = get_bits(&gb, 12);
 969             avctx->height = get_bits(&gb, 12);
 970             break;
 971         }
 972
 973         s->halfpel_flag  = get_bits1(&gb);
 974         s->thirdpel_flag = get_bits1(&gb);
 975
 976         /* unknown fields */
 977         skip_bits1(&gb);
 978         skip_bits1(&gb);
 979         skip_bits1(&gb);
 980         skip_bits1(&gb);
 981
 982         h->low_delay = get_bits1(&gb);
 983
 984         /* unknown field */
 985         skip_bits1(&gb);
 986
 987         if (skip_1stop_8data_bits(&gb) < 0) {
 988             ret = AVERROR_INVALIDDATA;
 989             goto fail;
 990         }
 991
 992         s->unknown_flag  = get_bits1(&gb);
 993         avctx->has_b_frames = !h->low_delay;
 994         if (s->unknown_flag) {
 995 #if CONFIG_ZLIB
 996             unsigned watermark_width  = svq3_get_ue_golomb(&gb);
 997             unsigned watermark_height = svq3_get_ue_golomb(&gb);
 998             int u1                    = svq3_get_ue_golomb(&gb);
 999             int u2                    = get_bits(&gb, 8);
1000             int u3                    = get_bits(&gb, 2);
1001             int u4                    = svq3_get_ue_golomb(&gb);
1002             unsigned long buf_len     = watermark_width *
1003                                         watermark_height * 4;
1004             int offset                = get_bits_count(&gb) + 7 >> 3;
1005             uint8_t *buf;
1006
1007             if (watermark_height <= 0 ||
1008                 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1009                 ret = -1;
1010                 goto fail;
1011             }
1012
1013             buf = av_malloc(buf_len);
1014             if (!buf) {
1015                 ret = AVERROR(ENOMEM);
1016                 goto fail;
1017             }
1018             av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1019                    watermark_width, watermark_height);
1020             av_log(avctx, AV_LOG_DEBUG,
1021                    "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1022                    u1, u2, u3, u4, offset);
1023             if (uncompress(buf, &buf_len, extradata + 8 + offset,
1024                            size - offset) != Z_OK) {
1025                 av_log(avctx, AV_LOG_ERROR,
1026                        "could not uncompress watermark logo\n");
1027                 av_free(buf);
1028                 ret = -1;
1029                 goto fail;
1030             }
1031             s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1032             s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1033             av_log(avctx, AV_LOG_DEBUG,
1034                    "watermark key %#"PRIx32"\n", s->watermark_key);
1035             av_free(buf);
1036 #else
1037             av_log(avctx, AV_LOG_ERROR,
1038                    "this svq3 file contains watermark which need zlib support compiled in\n");
1039             ret = -1;
1040             goto fail;
1041 #endif
1042         }
1043     }
1044
1045     h->width  = avctx->width;
1046     h->height = avctx->height;
1047     h->mb_width  = (h->width + 15) / 16;
1048     h->mb_height = (h->height + 15) / 16;
1049     h->mb_stride = h->mb_width + 1;
1050     h->mb_num    = h->mb_width * h->mb_height;
1051     h->b_stride = 4 * h->mb_width;
1052     s->h_edge_pos = h->mb_width * 16;
1053     s->v_edge_pos = h->mb_height * 16;
1054
1055     if ((ret = ff_h264_alloc_tables(h)) < 0) {
1056         av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1057         goto fail;
1058     }
1059
1060     return 0;
1061 fail:
1062     svq3_decode_end(avctx);
1063     return ret;
1064 }
1065
1066 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1067 {
1068     int i;
1069     for (i = 0; i < 2; i++) {
1070         av_buffer_unref(&pic->motion_val_buf[i]);
1071         av_buffer_unref(&pic->ref_index_buf[i]);
1072     }
1073     av_buffer_unref(&pic->mb_type_buf);
1074
1075     av_frame_unref(&pic->f);
1076 }
1077
1078 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1079 {
1080     SVQ3Context *s = avctx->priv_data;
1081     H264Context *h = &s->h;
1082     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
1083     const int mb_array_size = h->mb_stride * h->mb_height;
1084     const int b4_stride     = h->mb_width * 4 + 1;
1085     const int b4_array_size = b4_stride * h->mb_height * 4;
1086     int ret;
1087
1088     if (!pic->motion_val_buf[0]) {
1089         int i;
1090
1091         pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1092         if (!pic->mb_type_buf)
1093             return AVERROR(ENOMEM);
1094         pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1095
1096         for (i = 0; i < 2; i++) {
1097             pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1098             pic->ref_index_buf[i]  = av_buffer_allocz(4 * mb_array_size);
1099             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1100                 ret = AVERROR(ENOMEM);
1101                 goto fail;
1102             }
1103
1104             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1105             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
1106         }
1107     }
1108     pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1109
1110     ret = ff_get_buffer(avctx, &pic->f,
1111                         pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1112     if (ret < 0)
1113         goto fail;
1114
1115     if (!h->edge_emu_buffer) {
1116         h->edge_emu_buffer = av_mallocz_array(pic->f.linesize[0], 17);
1117         if (!h->edge_emu_buffer)
1118             return AVERROR(ENOMEM);
1119     }
1120
1121     h->linesize   = pic->f.linesize[0];
1122     h->uvlinesize = pic->f.linesize[1];
1123
1124     return 0;
1125 fail:
1126     free_picture(avctx, pic);
1127     return ret;
1128 }
1129
1130 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1131                              int *got_frame, AVPacket *avpkt)
1132 {
1133     SVQ3Context *s     = avctx->priv_data;
1134     H264Context *h     = &s->h;
1135     H264SliceContext *sl = &h->slice_ctx[0];
1136     int buf_size       = avpkt->size;
1137     int left;
1138     uint8_t *buf;
1139     int ret, m, i;
1140
1141     /* special case for last picture */
1142     if (buf_size == 0) {
1143         if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
1144             ret = av_frame_ref(data, &s->next_pic->f);
1145             if (ret < 0)
1146                 return ret;
1147             s->last_frame_output = 1;
1148             *got_frame          = 1;
1149         }
1150         return 0;
1151     }
1152
1153     h->mb_x = h->mb_y = h->mb_xy = 0;
1154
1155     if (s->watermark_key) {
1156         av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1157         if (!s->buf)
1158             return AVERROR(ENOMEM);
1159         memcpy(s->buf, avpkt->data, buf_size);
1160         buf = s->buf;
1161     } else {
1162         buf = avpkt->data;
1163     }
1164
1165     init_get_bits(&h->gb, buf, 8 * buf_size);
1166
1167     if (svq3_decode_slice_header(avctx))
1168         return -1;
1169
1170     h->pict_type = sl->slice_type;
1171
1172     if (h->pict_type != AV_PICTURE_TYPE_B)
1173         FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1174
1175     av_frame_unref(&s->cur_pic->f);
1176
1177     /* for skipping the frame */
1178     s->cur_pic->f.pict_type = h->pict_type;
1179     s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1180
1181     ret = get_buffer(avctx, s->cur_pic);
1182     if (ret < 0)
1183         return ret;
1184
1185     h->cur_pic_ptr = s->cur_pic;
1186     av_frame_unref(&h->cur_pic.f);
1187     memcpy(&h->cur_pic.tf, &s->cur_pic->tf, sizeof(h->cur_pic) - offsetof(H264Picture, tf));
1188     ret = av_frame_ref(&h->cur_pic.f, &s->cur_pic->f);
1189     if (ret < 0)
1190         return ret;
1191
1192     for (i = 0; i < 16; i++) {
1193         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1194         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1195     }
1196     for (i = 0; i < 16; i++) {
1197         h->block_offset[16 + i]      =
1198         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1199         h->block_offset[48 + 16 + i] =
1200         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1201     }
1202
1203     if (h->pict_type != AV_PICTURE_TYPE_I) {
1204         if (!s->last_pic->f.data[0]) {
1205             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1206             av_frame_unref(&s->last_pic->f);
1207             ret = get_buffer(avctx, s->last_pic);
1208             if (ret < 0)
1209                 return ret;
1210             memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1211             memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1212                    s->last_pic->f.linesize[1]);
1213             memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1214                    s->last_pic->f.linesize[2]);
1215         }
1216
1217         if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1218             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1219             av_frame_unref(&s->next_pic->f);
1220             ret = get_buffer(avctx, s->next_pic);
1221             if (ret < 0)
1222                 return ret;
1223             memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1224             memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1225                    s->next_pic->f.linesize[1]);
1226             memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1227                    s->next_pic->f.linesize[2]);
1228         }
1229     }
1230
1231     if (avctx->debug & FF_DEBUG_PICT_INFO)
1232         av_log(h->avctx, AV_LOG_DEBUG,
1233                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1234                av_get_picture_type_char(h->pict_type),
1235                s->halfpel_flag, s->thirdpel_flag,
1236                s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
1237
1238     if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1239         avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1240         avctx->skip_frame >= AVDISCARD_ALL)
1241         return 0;
1242
1243     if (s->next_p_frame_damaged) {
1244         if (h->pict_type == AV_PICTURE_TYPE_B)
1245             return 0;
1246         else
1247             s->next_p_frame_damaged = 0;
1248     }
1249
1250     if (h->pict_type == AV_PICTURE_TYPE_B) {
1251         h->frame_num_offset = sl->slice_num - h->prev_frame_num;
1252
1253         if (h->frame_num_offset < 0)
1254             h->frame_num_offset += 256;
1255         if (h->frame_num_offset == 0 ||
1256             h->frame_num_offset >= h->prev_frame_num_offset) {
1257             av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1258             return -1;
1259         }
1260     } else {
1261         h->prev_frame_num        = h->frame_num;
1262         h->frame_num             = sl->slice_num;
1263         h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1264
1265         if (h->prev_frame_num_offset < 0)
1266             h->prev_frame_num_offset += 256;
1267     }
1268
1269     for (m = 0; m < 2; m++) {
1270         int i;
1271         for (i = 0; i < 4; i++) {
1272             int j;
1273             for (j = -1; j < 4; j++)
1274                 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1275             if (i < 3)
1276                 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1277         }
1278     }
1279
1280     for (h->mb_y = 0; h->mb_y < h->mb_height; h->mb_y++) {
1281         for (h->mb_x = 0; h->mb_x < h->mb_width; h->mb_x++) {
1282             unsigned mb_type;
1283             h->mb_xy = h->mb_x + h->mb_y * h->mb_stride;
1284
1285             if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1286                 ((get_bits_count(&h->gb) & 7) == 0 ||
1287                  show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1288                 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1289                 h->gb.size_in_bits = 8 * buf_size;
1290
1291                 if (svq3_decode_slice_header(avctx))
1292                     return -1;
1293
1294                 /* TODO: support s->mb_skip_run */
1295             }
1296
1297             mb_type = svq3_get_ue_golomb(&h->gb);
1298
1299             if (h->pict_type == AV_PICTURE_TYPE_I)
1300                 mb_type += 8;
1301             else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1302                 mb_type += 4;
1303             if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1304                 av_log(h->avctx, AV_LOG_ERROR,
1305                        "error while decoding MB %d %d\n", h->mb_x, h->mb_y);
1306                 return -1;
1307             }
1308
1309             if (mb_type != 0 || h->cbp)
1310                 ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
1311
1312             if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1313                 h->cur_pic.mb_type[h->mb_x + h->mb_y * h->mb_stride] =
1314                     (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1315         }
1316
1317         ff_draw_horiz_band(avctx, &s->cur_pic->f,
1318                            s->last_pic->f.data[0] ? &s->last_pic->f : NULL,
1319                            16 * h->mb_y, 16, h->picture_structure, 0,
1320                            h->low_delay);
1321     }
1322
1323     left = buf_size*8 - get_bits_count(&h->gb);
1324
1325     if (h->mb_y != h->mb_height || h->mb_x != h->mb_width) {
1326         av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, h->mb_y, h->mb_x, left);
1327         //av_hex_dump(stderr, buf+buf_size-8, 8);
1328     }
1329
1330     if (left < 0) {
1331         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1332         return -1;
1333     }
1334
1335     if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1336         ret = av_frame_ref(data, &s->cur_pic->f);
1337     else if (s->last_pic->f.data[0])
1338         ret = av_frame_ref(data, &s->last_pic->f);
1339     if (ret < 0)
1340         return ret;
1341
1342     /* Do not output the last pic after seeking. */
1343     if (s->last_pic->f.data[0] || h->low_delay)
1344         *got_frame = 1;
1345
1346     if (h->pict_type != AV_PICTURE_TYPE_B) {
1347         FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1348     } else {
1349         av_frame_unref(&s->cur_pic->f);
1350     }
1351
1352     return buf_size;
1353 }
1354
1355 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1356 {
1357     SVQ3Context *s = avctx->priv_data;
1358     H264Context *h = &s->h;
1359
1360     free_picture(avctx, s->cur_pic);
1361     free_picture(avctx, s->next_pic);
1362     free_picture(avctx, s->last_pic);
1363     av_freep(&s->cur_pic);
1364     av_freep(&s->next_pic);
1365     av_freep(&s->last_pic);
1366
1367     av_frame_unref(&h->cur_pic.f);
1368
1369     ff_h264_free_context(h);
1370
1371     av_freep(&s->buf);
1372     s->buf_size = 0;
1373     av_freep(&h->edge_emu_buffer);
1374
1375     return 0;
1376 }
1377
1378 AVCodec ff_svq3_decoder = {
1379     .name           = "svq3",
1380     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1381     .type           = AVMEDIA_TYPE_VIDEO,
1382     .id             = AV_CODEC_ID_SVQ3,
1383     .priv_data_size = sizeof(SVQ3Context),
1384     .init           = svq3_decode_init,
1385     .close          = svq3_decode_end,
1386     .decode         = svq3_decode_frame,
1387     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND |
1388                       CODEC_CAP_DR1             |
1389                       CODEC_CAP_DELAY,
1390     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1391                                                      AV_PIX_FMT_NONE},
1392 };