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