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     H264SliceContext *sl = &h->slice_ctx[0];
 307     const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
 308     uint8_t *src, *dest;
 309     int i, emu = 0;
 310     int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
 311
 312     mx += x;
 313     my += y;
 314
 315     if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
 316         my < 0 || my >= s->v_edge_pos - height - 1) {
 317         emu = 1;
 318         mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
 319         my = av_clip(my, -16, s->v_edge_pos - height + 15);
 320     }
 321
 322     /* form component predictions */
 323     dest = h->cur_pic.f.data[0] + x + y * sl->linesize;
 324     src  = pic->f.data[0] + mx + my * sl->linesize;
 325
 326     if (emu) {
 327         h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
 328                                  sl->linesize, sl->linesize,
 329                                  width + 1, height + 1,
 330                                  mx, my, s->h_edge_pos, s->v_edge_pos);
 331         src = sl->edge_emu_buffer;
 332     }
 333     if (thirdpel)
 334         (avg ? s->tdsp.avg_tpel_pixels_tab
 335              : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, sl->linesize,
 336                                                  width, height);
 337     else
 338         (avg ? s->hdsp.avg_pixels_tab
 339              : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, sl->linesize,
 340                                                        height);
 341
 342     if (!(h->flags & CODEC_FLAG_GRAY)) {
 343         mx     = mx + (mx < (int) x) >> 1;
 344         my     = my + (my < (int) y) >> 1;
 345         width  = width  >> 1;
 346         height = height >> 1;
 347         blocksize++;
 348
 349         for (i = 1; i < 3; i++) {
 350             dest = h->cur_pic.f.data[i] + (x >> 1) + (y >> 1) * sl->uvlinesize;
 351             src  = pic->f.data[i] + mx + my * sl->uvlinesize;
 352
 353             if (emu) {
 354                 h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src,
 355                                          sl->uvlinesize, sl->uvlinesize,
 356                                          width + 1, height + 1,
 357                                          mx, my, (s->h_edge_pos >> 1),
 358                                          s->v_edge_pos >> 1);
 359                 src = sl->edge_emu_buffer;
 360             }
 361             if (thirdpel)
 362                 (avg ? s->tdsp.avg_tpel_pixels_tab
 363                      : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
 364                                                          sl->uvlinesize,
 365                                                          width, height);
 366             else
 367                 (avg ? s->hdsp.avg_pixels_tab
 368                      : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
 369                                                                sl->uvlinesize,
 370                                                                height);
 371         }
 372     }
 373 }
 374
 375 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
 376                               int dir, int avg)
 377 {
 378     int i, j, k, mx, my, dx, dy, x, y;
 379     H264Context *h          = &s->h;
 380     H264SliceContext *sl    = &h->slice_ctx[0];
 381     const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 382     const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
 383     const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
 384     const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
 385     const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;
 386
 387     for (i = 0; i < 16; i += part_height)
 388         for (j = 0; j < 16; j += part_width) {
 389             const int b_xy = (4 * sl->mb_x + (j >> 2)) +
 390                              (4 * sl->mb_y + (i >> 2)) * h->b_stride;
 391             int dxy;
 392             x = 16 * sl->mb_x + j;
 393             y = 16 * sl->mb_y + i;
 394             k = (j >> 2 & 1) + (i >> 1 & 2) +
 395                 (j >> 1 & 4) + (i      & 8);
 396
 397             if (mode != PREDICT_MODE) {
 398                 pred_motion(h, sl, k, part_width >> 2, dir, 1, &mx, &my);
 399             } else {
 400                 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
 401                 my = s->next_pic->motion_val[0][b_xy][1] << 1;
 402
 403                 if (dir == 0) {
 404                     mx = mx * h->frame_num_offset /
 405                          h->prev_frame_num_offset + 1 >> 1;
 406                     my = my * h->frame_num_offset /
 407                          h->prev_frame_num_offset + 1 >> 1;
 408                 } else {
 409                     mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
 410                          h->prev_frame_num_offset + 1 >> 1;
 411                     my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
 412                          h->prev_frame_num_offset + 1 >> 1;
 413                 }
 414             }
 415
 416             /* clip motion vector prediction to frame border */
 417             mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
 418             my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
 419
 420             /* get (optional) motion vector differential */
 421             if (mode == PREDICT_MODE) {
 422                 dx = dy = 0;
 423             } else {
 424                 dy = svq3_get_se_golomb(&h->gb);
 425                 dx = svq3_get_se_golomb(&h->gb);
 426
 427                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 428                     av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 429                     return -1;
 430                 }
 431             }
 432
 433             /* compute motion vector */
 434             if (mode == THIRDPEL_MODE) {
 435                 int fx, fy;
 436                 mx  = (mx + 1 >> 1) + dx;
 437                 my  = (my + 1 >> 1) + dy;
 438                 fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
 439                 fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
 440                 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
 441
 442                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 443                                  fx, fy, dxy, 1, dir, avg);
 444                 mx += mx;
 445                 my += my;
 446             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 447                 mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
 448                 my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
 449                 dxy = (mx & 1) + 2 * (my & 1);
 450
 451                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 452                                  mx >> 1, my >> 1, dxy, 0, dir, avg);
 453                 mx *= 3;
 454                 my *= 3;
 455             } else {
 456                 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
 457                 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
 458
 459                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 460                                  mx, my, 0, 0, dir, avg);
 461                 mx *= 6;
 462                 my *= 6;
 463             }
 464
 465             /* update mv_cache */
 466             if (mode != PREDICT_MODE) {
 467                 int32_t mv = pack16to32(mx, my);
 468
 469                 if (part_height == 8 && i < 8) {
 470                     AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 * 8], mv);
 471
 472                     if (part_width == 8 && j < 8)
 473                         AV_WN32A(sl->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
 474                 }
 475                 if (part_width == 8 && j < 8)
 476                     AV_WN32A(sl->mv_cache[dir][scan8[k] + 1], mv);
 477                 if (part_width == 4 || part_height == 4)
 478                     AV_WN32A(sl->mv_cache[dir][scan8[k]], mv);
 479             }
 480
 481             /* write back motion vectors */
 482             fill_rectangle(h->cur_pic.motion_val[dir][b_xy],
 483                            part_width >> 2, part_height >> 2, h->b_stride,
 484                            pack16to32(mx, my), 4);
 485         }
 486
 487     return 0;
 488 }
 489
 490 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
 491 {
 492     H264Context *h = &s->h;
 493     H264SliceContext *sl = &h->slice_ctx[0];
 494     int i, j, k, m, dir, mode;
 495     int cbp = 0;
 496     uint32_t vlc;
 497     int8_t *top, *left;
 498     const int mb_xy         = sl->mb_xy;
 499     const int b_xy          = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride;
 500
 501     sl->top_samples_available      = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
 502     sl->left_samples_available     = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
 503     sl->topright_samples_available = 0xFFFF;
 504
 505     if (mb_type == 0) {           /* SKIP */
 506         if (h->pict_type == AV_PICTURE_TYPE_P ||
 507             s->next_pic->mb_type[mb_xy] == -1) {
 508             svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
 509                              0, 0, 0, 0, 0, 0);
 510
 511             if (h->pict_type == AV_PICTURE_TYPE_B)
 512                 svq3_mc_dir_part(s, 16 * sl->mb_x, 16 * sl->mb_y, 16, 16,
 513                                  0, 0, 0, 0, 1, 1);
 514
 515             mb_type = MB_TYPE_SKIP;
 516         } else {
 517             mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
 518             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
 519                 return -1;
 520             if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
 521                 return -1;
 522
 523             mb_type = MB_TYPE_16x16;
 524         }
 525     } else if (mb_type < 8) {     /* INTER */
 526         if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
 527             mode = THIRDPEL_MODE;
 528         else if (s->halfpel_flag &&
 529                  s->thirdpel_flag == !get_bits1(&h->gb))
 530             mode = HALFPEL_MODE;
 531         else
 532             mode = FULLPEL_MODE;
 533
 534         /* fill caches */
 535         /* note ref_cache should contain here:
 536          *  ????????
 537          *  ???11111
 538          *  N??11111
 539          *  N??11111
 540          *  N??11111
 541          */
 542
 543         for (m = 0; m < 2; m++) {
 544             if (sl->mb_x > 0 && sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
 545                 for (i = 0; i < 4; i++)
 546                     AV_COPY32(sl->mv_cache[m][scan8[0] - 1 + i * 8],
 547                               h->cur_pic.motion_val[m][b_xy - 1 + i * h->b_stride]);
 548             } else {
 549                 for (i = 0; i < 4; i++)
 550                     AV_ZERO32(sl->mv_cache[m][scan8[0] - 1 + i * 8]);
 551             }
 552             if (sl->mb_y > 0) {
 553                 memcpy(sl->mv_cache[m][scan8[0] - 1 * 8],
 554                        h->cur_pic.motion_val[m][b_xy - h->b_stride],
 555                        4 * 2 * sizeof(int16_t));
 556                 memset(&sl->ref_cache[m][scan8[0] - 1 * 8],
 557                        (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 558
 559                 if (sl->mb_x < h->mb_width - 1) {
 560                     AV_COPY32(sl->mv_cache[m][scan8[0] + 4 - 1 * 8],
 561                               h->cur_pic.motion_val[m][b_xy - h->b_stride + 4]);
 562                     sl->ref_cache[m][scan8[0] + 4 - 1 * 8] =
 563                         (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
 564                          sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
 565                 } else
 566                     sl->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
 567                 if (sl->mb_x > 0) {
 568                     AV_COPY32(sl->mv_cache[m][scan8[0] - 1 - 1 * 8],
 569                               h->cur_pic.motion_val[m][b_xy - h->b_stride - 1]);
 570                     sl->ref_cache[m][scan8[0] - 1 - 1 * 8] =
 571                         (sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
 572                 } else
 573                     sl->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
 574             } else
 575                 memset(&sl->ref_cache[m][scan8[0] - 1 * 8 - 1],
 576                        PART_NOT_AVAILABLE, 8);
 577
 578             if (h->pict_type != AV_PICTURE_TYPE_B)
 579                 break;
 580         }
 581
 582         /* decode motion vector(s) and form prediction(s) */
 583         if (h->pict_type == AV_PICTURE_TYPE_P) {
 584             if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
 585                 return -1;
 586         } else {        /* AV_PICTURE_TYPE_B */
 587             if (mb_type != 2) {
 588                 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
 589                     return -1;
 590             } else {
 591                 for (i = 0; i < 4; i++)
 592                     memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
 593                            0, 4 * 2 * sizeof(int16_t));
 594             }
 595             if (mb_type != 1) {
 596                 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
 597                     return -1;
 598             } else {
 599                 for (i = 0; i < 4; i++)
 600                     memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
 601                            0, 4 * 2 * sizeof(int16_t));
 602             }
 603         }
 604
 605         mb_type = MB_TYPE_16x16;
 606     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 607         memset(sl->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
 608
 609         if (mb_type == 8) {
 610             if (sl->mb_x > 0) {
 611                 for (i = 0; i < 4; i++)
 612                     sl->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
 613                 if (sl->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
 614                     sl->left_samples_available = 0x5F5F;
 615             }
 616             if (sl->mb_y > 0) {
 617                 sl->intra4x4_pred_mode_cache[4 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
 618                 sl->intra4x4_pred_mode_cache[5 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
 619                 sl->intra4x4_pred_mode_cache[6 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
 620                 sl->intra4x4_pred_mode_cache[7 + 8 * 0] = sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
 621
 622                 if (sl->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
 623                     sl->top_samples_available = 0x33FF;
 624             }
 625
 626             /* decode prediction codes for luma blocks */
 627             for (i = 0; i < 16; i += 2) {
 628                 vlc = svq3_get_ue_golomb(&h->gb);
 629
 630                 if (vlc >= 25U) {
 631                     av_log(h->avctx, AV_LOG_ERROR,
 632                            "luma prediction:%"PRIu32"\n", vlc);
 633                     return -1;
 634                 }
 635
 636                 left = &sl->intra4x4_pred_mode_cache[scan8[i] - 1];
 637                 top  = &sl->intra4x4_pred_mode_cache[scan8[i] - 8];
 638
 639                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 640                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 641
 642                 if (left[1] == -1 || left[2] == -1) {
 643                     av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
 644                     return -1;
 645                 }
 646             }
 647         } else {    /* mb_type == 33, DC_128_PRED block type */
 648             for (i = 0; i < 4; i++)
 649                 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
 650         }
 651
 652         write_back_intra_pred_mode(h, sl);
 653
 654         if (mb_type == 8) {
 655             ff_h264_check_intra4x4_pred_mode(h, sl);
 656
 657             sl->top_samples_available  = (sl->mb_y == 0) ? 0x33FF : 0xFFFF;
 658             sl->left_samples_available = (sl->mb_x == 0) ? 0x5F5F : 0xFFFF;
 659         } else {
 660             for (i = 0; i < 4; i++)
 661                 memset(&sl->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
 662
 663             sl->top_samples_available  = 0x33FF;
 664             sl->left_samples_available = 0x5F5F;
 665         }
 666
 667         mb_type = MB_TYPE_INTRA4x4;
 668     } else {                      /* INTRA16x16 */
 669         dir = i_mb_type_info[mb_type - 8].pred_mode;
 670         dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
 671
 672         if ((sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, sl, dir, 0)) < 0) {
 673             av_log(h->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
 674             return sl->intra16x16_pred_mode;
 675         }
 676
 677         cbp     = i_mb_type_info[mb_type - 8].cbp;
 678         mb_type = MB_TYPE_INTRA16x16;
 679     }
 680
 681     if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
 682         for (i = 0; i < 4; i++)
 683             memset(h->cur_pic.motion_val[0][b_xy + i * h->b_stride],
 684                    0, 4 * 2 * sizeof(int16_t));
 685         if (h->pict_type == AV_PICTURE_TYPE_B) {
 686             for (i = 0; i < 4; i++)
 687                 memset(h->cur_pic.motion_val[1][b_xy + i * h->b_stride],
 688                        0, 4 * 2 * sizeof(int16_t));
 689         }
 690     }
 691     if (!IS_INTRA4x4(mb_type)) {
 692         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
 693     }
 694     if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
 695         memset(sl->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
 696     }
 697
 698     if (!IS_INTRA16x16(mb_type) &&
 699         (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
 700         if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48U){
 701             av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
 702             return -1;
 703         }
 704
 705         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
 706                                 : golomb_to_inter_cbp[vlc];
 707     }
 708     if (IS_INTRA16x16(mb_type) ||
 709         (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 710         sl->qscale += svq3_get_se_golomb(&h->gb);
 711
 712         if (sl->qscale > 31u) {
 713             av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", sl->qscale);
 714             return -1;
 715         }
 716     }
 717     if (IS_INTRA16x16(mb_type)) {
 718         AV_ZERO128(sl->mb_luma_dc[0] + 0);
 719         AV_ZERO128(sl->mb_luma_dc[0] + 8);
 720         if (svq3_decode_block(&h->gb, sl->mb_luma_dc[0], 0, 1)) {
 721             av_log(h->avctx, AV_LOG_ERROR,
 722                    "error while decoding intra luma dc\n");
 723             return -1;
 724         }
 725     }
 726
 727     if (cbp) {
 728         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 729         const int type  = ((sl->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 730
 731         for (i = 0; i < 4; i++)
 732             if ((cbp & (1 << i))) {
 733                 for (j = 0; j < 4; j++) {
 734                     k = index ? (1 * (j & 1) + 2 * (i & 1) +
 735                                  2 * (j & 2) + 4 * (i & 2))
 736                               : (4 * i + j);
 737                     sl->non_zero_count_cache[scan8[k]] = 1;
 738
 739                     if (svq3_decode_block(&h->gb, &sl->mb[16 * k], index, type)) {
 740                         av_log(h->avctx, AV_LOG_ERROR,
 741                                "error while decoding block\n");
 742                         return -1;
 743                     }
 744                 }
 745             }
 746
 747         if ((cbp & 0x30)) {
 748             for (i = 1; i < 3; ++i)
 749                 if (svq3_decode_block(&h->gb, &sl->mb[16 * 16 * i], 0, 3)) {
 750                     av_log(h->avctx, AV_LOG_ERROR,
 751                            "error while decoding chroma dc block\n");
 752                     return -1;
 753                 }
 754
 755             if ((cbp & 0x20)) {
 756                 for (i = 1; i < 3; i++) {
 757                     for (j = 0; j < 4; j++) {
 758                         k                                 = 16 * i + j;
 759                         sl->non_zero_count_cache[scan8[k]] = 1;
 760
 761                         if (svq3_decode_block(&h->gb, &sl->mb[16 * k], 1, 1)) {
 762                             av_log(h->avctx, AV_LOG_ERROR,
 763                                    "error while decoding chroma ac block\n");
 764                             return -1;
 765                         }
 766                     }
 767                 }
 768             }
 769         }
 770     }
 771
 772     sl->cbp                   = cbp;
 773     h->cur_pic.mb_type[mb_xy] = mb_type;
 774
 775     if (IS_INTRA(mb_type))
 776         sl->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, sl, DC_PRED8x8, 1);
 777
 778     return 0;
 779 }
 780
 781 static int svq3_decode_slice_header(AVCodecContext *avctx)
 782 {
 783     SVQ3Context *s = avctx->priv_data;
 784     H264Context *h    = &s->h;
 785     H264SliceContext *sl = &h->slice_ctx[0];
 786     const int mb_xy   = sl->mb_xy;
 787     int i, header;
 788     unsigned slice_id;
 789
 790     header = get_bits(&h->gb, 8);
 791
 792     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
 793         /* TODO: what? */
 794         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
 795         return -1;
 796     } else {
 797         int length = header >> 5 & 3;
 798
 799         s->next_slice_index = get_bits_count(&h->gb) +
 800                               8 * show_bits(&h->gb, 8 * length) +
 801                               8 * length;
 802
 803         if (s->next_slice_index > h->gb.size_in_bits) {
 804             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
 805             return -1;
 806         }
 807
 808         h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
 809         skip_bits(&h->gb, 8);
 810
 811         if (s->watermark_key) {
 812             uint32_t header = AV_RL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1]);
 813             AV_WL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1],
 814                     header ^ s->watermark_key);
 815         }
 816         if (length > 0) {
 817             memmove((uint8_t *) &h->gb.buffer[get_bits_count(&h->gb) >> 3],
 818                     &h->gb.buffer[h->gb.size_in_bits >> 3], length - 1);
 819         }
 820         skip_bits_long(&h->gb, 0);
 821     }
 822
 823     if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
 824         av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
 825         return -1;
 826     }
 827
 828     sl->slice_type = golomb_to_pict_type[slice_id];
 829
 830     if ((header & 0x9F) == 2) {
 831         i              = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
 832         sl->mb_skip_run = get_bits(&h->gb, i) -
 833                          (sl->mb_y * h->mb_width + sl->mb_x);
 834     } else {
 835         skip_bits1(&h->gb);
 836         sl->mb_skip_run = 0;
 837     }
 838
 839     sl->slice_num     = get_bits(&h->gb, 8);
 840     sl->qscale        = get_bits(&h->gb, 5);
 841     s->adaptive_quant = get_bits1(&h->gb);
 842
 843     /* unknown fields */
 844     skip_bits1(&h->gb);
 845
 846     if (s->unknown_flag)
 847         skip_bits1(&h->gb);
 848
 849     skip_bits1(&h->gb);
 850     skip_bits(&h->gb, 2);
 851
 852     if (skip_1stop_8data_bits(&h->gb) < 0)
 853         return AVERROR_INVALIDDATA;
 854
 855     /* reset intra predictors and invalidate motion vector references */
 856     if (sl->mb_x > 0) {
 857         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
 858                -1, 4 * sizeof(int8_t));
 859         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - sl->mb_x],
 860                -1, 8 * sizeof(int8_t) * sl->mb_x);
 861     }
 862     if (sl->mb_y > 0) {
 863         memset(sl->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
 864                -1, 8 * sizeof(int8_t) * (h->mb_width - sl->mb_x));
 865
 866         if (sl->mb_x > 0)
 867             sl->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
 868     }
 869
 870     return 0;
 871 }
 872
 873 static av_cold int svq3_decode_init(AVCodecContext *avctx)
 874 {
 875     SVQ3Context *s = avctx->priv_data;
 876     H264Context *h = &s->h;
 877     H264SliceContext *sl;
 878     int m;
 879     unsigned char *extradata;
 880     unsigned char *extradata_end;
 881     unsigned int size;
 882     int marker_found = 0;
 883     int ret;
 884
 885     s->cur_pic  = av_mallocz(sizeof(*s->cur_pic));
 886     s->last_pic = av_mallocz(sizeof(*s->last_pic));
 887     s->next_pic = av_mallocz(sizeof(*s->next_pic));
 888     if (!s->next_pic || !s->last_pic || !s->cur_pic) {
 889         ret = AVERROR(ENOMEM);
 890         goto fail;
 891     }
 892
 893     if ((ret = ff_h264_decode_init(avctx)) < 0)
 894         goto fail;
 895
 896     ff_h264dsp_init(&h->h264dsp, 8, 1);
 897     av_assert0(h->sps.bit_depth_chroma == 0);
 898     ff_h264_pred_init(&h->hpc, AV_CODEC_ID_SVQ3, 8, 1);
 899     ff_videodsp_init(&h->vdsp, 8);
 900
 901     memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
 902     memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
 903
 904     avctx->bits_per_raw_sample = 8;
 905     h->sps.bit_depth_luma = 8;
 906     h->chroma_format_idc = 1;
 907
 908     ff_hpeldsp_init(&s->hdsp, avctx->flags);
 909     ff_tpeldsp_init(&s->tdsp);
 910
 911     sl = h->slice_ctx;
 912
 913     h->flags           = avctx->flags;
 914     sl->is_complex     = 1;
 915     h->sps.chroma_format_idc = 1;
 916     h->picture_structure = PICT_FRAME;
 917     avctx->pix_fmt     = AV_PIX_FMT_YUVJ420P;
 918     avctx->color_range = AVCOL_RANGE_JPEG;
 919
 920     h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
 921     h->chroma_x_shift = h->chroma_y_shift = 1;
 922
 923     s->halfpel_flag  = 1;
 924     s->thirdpel_flag = 1;
 925     s->unknown_flag  = 0;
 926
 927     /* prowl for the "SEQH" marker in the extradata */
 928     extradata     = (unsigned char *)avctx->extradata;
 929     extradata_end = avctx->extradata + avctx->extradata_size;
 930     if (extradata) {
 931         for (m = 0; m + 8 < avctx->extradata_size; m++) {
 932             if (!memcmp(extradata, "SEQH", 4)) {
 933                 marker_found = 1;
 934                 break;
 935             }
 936             extradata++;
 937         }
 938     }
 939
 940     /* if a match was found, parse the extra data */
 941     if (marker_found) {
 942         GetBitContext gb;
 943         int frame_size_code;
 944
 945         size = AV_RB32(&extradata[4]);
 946         if (size > extradata_end - extradata - 8) {
 947             ret = AVERROR_INVALIDDATA;
 948             goto fail;
 949         }
 950         init_get_bits(&gb, extradata + 8, size * 8);
 951
 952         /* 'frame size code' and optional 'width, height' */
 953         frame_size_code = get_bits(&gb, 3);
 954         switch (frame_size_code) {
 955         case 0:
 956             avctx->width  = 160;
 957             avctx->height = 120;
 958             break;
 959         case 1:
 960             avctx->width  = 128;
 961             avctx->height =  96;
 962             break;
 963         case 2:
 964             avctx->width  = 176;
 965             avctx->height = 144;
 966             break;
 967         case 3:
 968             avctx->width  = 352;
 969             avctx->height = 288;
 970             break;
 971         case 4:
 972             avctx->width  = 704;
 973             avctx->height = 576;
 974             break;
 975         case 5:
 976             avctx->width  = 240;
 977             avctx->height = 180;
 978             break;
 979         case 6:
 980             avctx->width  = 320;
 981             avctx->height = 240;
 982             break;
 983         case 7:
 984             avctx->width  = get_bits(&gb, 12);
 985             avctx->height = get_bits(&gb, 12);
 986             break;
 987         }
 988
 989         s->halfpel_flag  = get_bits1(&gb);
 990         s->thirdpel_flag = get_bits1(&gb);
 991
 992         /* unknown fields */
 993         skip_bits1(&gb);
 994         skip_bits1(&gb);
 995         skip_bits1(&gb);
 996         skip_bits1(&gb);
 997
 998         h->low_delay = get_bits1(&gb);
 999
1000         /* unknown field */
1001         skip_bits1(&gb);
1002
1003         if (skip_1stop_8data_bits(&gb) < 0) {
1004             ret = AVERROR_INVALIDDATA;
1005             goto fail;
1006         }
1007
1008         s->unknown_flag  = get_bits1(&gb);
1009         avctx->has_b_frames = !h->low_delay;
1010         if (s->unknown_flag) {
1011 #if CONFIG_ZLIB
1012             unsigned watermark_width  = svq3_get_ue_golomb(&gb);
1013             unsigned watermark_height = svq3_get_ue_golomb(&gb);
1014             int u1                    = svq3_get_ue_golomb(&gb);
1015             int u2                    = get_bits(&gb, 8);
1016             int u3                    = get_bits(&gb, 2);
1017             int u4                    = svq3_get_ue_golomb(&gb);
1018             unsigned long buf_len     = watermark_width *
1019                                         watermark_height * 4;
1020             int offset                = get_bits_count(&gb) + 7 >> 3;
1021             uint8_t *buf;
1022
1023             if (watermark_height <= 0 ||
1024                 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1025                 ret = -1;
1026                 goto fail;
1027             }
1028
1029             buf = av_malloc(buf_len);
1030             if (!buf) {
1031                 ret = AVERROR(ENOMEM);
1032                 goto fail;
1033             }
1034             av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1035                    watermark_width, watermark_height);
1036             av_log(avctx, AV_LOG_DEBUG,
1037                    "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1038                    u1, u2, u3, u4, offset);
1039             if (uncompress(buf, &buf_len, extradata + 8 + offset,
1040                            size - offset) != Z_OK) {
1041                 av_log(avctx, AV_LOG_ERROR,
1042                        "could not uncompress watermark logo\n");
1043                 av_free(buf);
1044                 ret = -1;
1045                 goto fail;
1046             }
1047             s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1048             s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1049             av_log(avctx, AV_LOG_DEBUG,
1050                    "watermark key %#"PRIx32"\n", s->watermark_key);
1051             av_free(buf);
1052 #else
1053             av_log(avctx, AV_LOG_ERROR,
1054                    "this svq3 file contains watermark which need zlib support compiled in\n");
1055             ret = -1;
1056             goto fail;
1057 #endif
1058         }
1059     }
1060
1061     h->width  = avctx->width;
1062     h->height = avctx->height;
1063     h->mb_width  = (h->width + 15) / 16;
1064     h->mb_height = (h->height + 15) / 16;
1065     h->mb_stride = h->mb_width + 1;
1066     h->mb_num    = h->mb_width * h->mb_height;
1067     h->b_stride = 4 * h->mb_width;
1068     s->h_edge_pos = h->mb_width * 16;
1069     s->v_edge_pos = h->mb_height * 16;
1070
1071     if ((ret = ff_h264_alloc_tables(h)) < 0) {
1072         av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1073         goto fail;
1074     }
1075
1076     return 0;
1077 fail:
1078     svq3_decode_end(avctx);
1079     return ret;
1080 }
1081
1082 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1083 {
1084     int i;
1085     for (i = 0; i < 2; i++) {
1086         av_buffer_unref(&pic->motion_val_buf[i]);
1087         av_buffer_unref(&pic->ref_index_buf[i]);
1088     }
1089     av_buffer_unref(&pic->mb_type_buf);
1090
1091     av_frame_unref(&pic->f);
1092 }
1093
1094 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1095 {
1096     SVQ3Context *s = avctx->priv_data;
1097     H264Context *h = &s->h;
1098     H264SliceContext *sl = &h->slice_ctx[0];
1099     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
1100     const int mb_array_size = h->mb_stride * h->mb_height;
1101     const int b4_stride     = h->mb_width * 4 + 1;
1102     const int b4_array_size = b4_stride * h->mb_height * 4;
1103     int ret;
1104
1105     if (!pic->motion_val_buf[0]) {
1106         int i;
1107
1108         pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1109         if (!pic->mb_type_buf)
1110             return AVERROR(ENOMEM);
1111         pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1112
1113         for (i = 0; i < 2; i++) {
1114             pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1115             pic->ref_index_buf[i]  = av_buffer_allocz(4 * mb_array_size);
1116             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1117                 ret = AVERROR(ENOMEM);
1118                 goto fail;
1119             }
1120
1121             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1122             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
1123         }
1124     }
1125     pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1126
1127     ret = ff_get_buffer(avctx, &pic->f,
1128                         pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1129     if (ret < 0)
1130         goto fail;
1131
1132     if (!sl->edge_emu_buffer) {
1133         sl->edge_emu_buffer = av_mallocz_array(pic->f.linesize[0], 17);
1134         if (!sl->edge_emu_buffer)
1135             return AVERROR(ENOMEM);
1136     }
1137
1138     sl->linesize   = pic->f.linesize[0];
1139     sl->uvlinesize = pic->f.linesize[1];
1140
1141     return 0;
1142 fail:
1143     free_picture(avctx, pic);
1144     return ret;
1145 }
1146
1147 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1148                              int *got_frame, AVPacket *avpkt)
1149 {
1150     SVQ3Context *s     = avctx->priv_data;
1151     H264Context *h     = &s->h;
1152     H264SliceContext *sl = &h->slice_ctx[0];
1153     int buf_size       = avpkt->size;
1154     int left;
1155     uint8_t *buf;
1156     int ret, m, i;
1157
1158     /* special case for last picture */
1159     if (buf_size == 0) {
1160         if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
1161             ret = av_frame_ref(data, &s->next_pic->f);
1162             if (ret < 0)
1163                 return ret;
1164             s->last_frame_output = 1;
1165             *got_frame          = 1;
1166         }
1167         return 0;
1168     }
1169
1170     sl->mb_x = sl->mb_y = sl->mb_xy = 0;
1171
1172     if (s->watermark_key) {
1173         av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1174         if (!s->buf)
1175             return AVERROR(ENOMEM);
1176         memcpy(s->buf, avpkt->data, buf_size);
1177         buf = s->buf;
1178     } else {
1179         buf = avpkt->data;
1180     }
1181
1182     init_get_bits(&h->gb, buf, 8 * buf_size);
1183
1184     if (svq3_decode_slice_header(avctx))
1185         return -1;
1186
1187     h->pict_type = sl->slice_type;
1188
1189     if (h->pict_type != AV_PICTURE_TYPE_B)
1190         FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1191
1192     av_frame_unref(&s->cur_pic->f);
1193
1194     /* for skipping the frame */
1195     s->cur_pic->f.pict_type = h->pict_type;
1196     s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1197
1198     ret = get_buffer(avctx, s->cur_pic);
1199     if (ret < 0)
1200         return ret;
1201
1202     h->cur_pic_ptr = s->cur_pic;
1203     av_frame_unref(&h->cur_pic.f);
1204     memcpy(&h->cur_pic.tf, &s->cur_pic->tf, sizeof(h->cur_pic) - offsetof(H264Picture, tf));
1205     ret = av_frame_ref(&h->cur_pic.f, &s->cur_pic->f);
1206     if (ret < 0)
1207         return ret;
1208
1209     for (i = 0; i < 16; i++) {
1210         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1211         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1212     }
1213     for (i = 0; i < 16; i++) {
1214         h->block_offset[16 + i]      =
1215         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1216         h->block_offset[48 + 16 + i] =
1217         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1218     }
1219
1220     if (h->pict_type != AV_PICTURE_TYPE_I) {
1221         if (!s->last_pic->f.data[0]) {
1222             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1223             av_frame_unref(&s->last_pic->f);
1224             ret = get_buffer(avctx, s->last_pic);
1225             if (ret < 0)
1226                 return ret;
1227             memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1228             memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1229                    s->last_pic->f.linesize[1]);
1230             memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1231                    s->last_pic->f.linesize[2]);
1232         }
1233
1234         if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1235             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1236             av_frame_unref(&s->next_pic->f);
1237             ret = get_buffer(avctx, s->next_pic);
1238             if (ret < 0)
1239                 return ret;
1240             memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1241             memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1242                    s->next_pic->f.linesize[1]);
1243             memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1244                    s->next_pic->f.linesize[2]);
1245         }
1246     }
1247
1248     if (avctx->debug & FF_DEBUG_PICT_INFO)
1249         av_log(h->avctx, AV_LOG_DEBUG,
1250                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1251                av_get_picture_type_char(h->pict_type),
1252                s->halfpel_flag, s->thirdpel_flag,
1253                s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
1254
1255     if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1256         avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1257         avctx->skip_frame >= AVDISCARD_ALL)
1258         return 0;
1259
1260     if (s->next_p_frame_damaged) {
1261         if (h->pict_type == AV_PICTURE_TYPE_B)
1262             return 0;
1263         else
1264             s->next_p_frame_damaged = 0;
1265     }
1266
1267     if (h->pict_type == AV_PICTURE_TYPE_B) {
1268         h->frame_num_offset = sl->slice_num - h->prev_frame_num;
1269
1270         if (h->frame_num_offset < 0)
1271             h->frame_num_offset += 256;
1272         if (h->frame_num_offset == 0 ||
1273             h->frame_num_offset >= h->prev_frame_num_offset) {
1274             av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1275             return -1;
1276         }
1277     } else {
1278         h->prev_frame_num        = h->frame_num;
1279         h->frame_num             = sl->slice_num;
1280         h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1281
1282         if (h->prev_frame_num_offset < 0)
1283             h->prev_frame_num_offset += 256;
1284     }
1285
1286     for (m = 0; m < 2; m++) {
1287         int i;
1288         for (i = 0; i < 4; i++) {
1289             int j;
1290             for (j = -1; j < 4; j++)
1291                 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1292             if (i < 3)
1293                 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1294         }
1295     }
1296
1297     for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
1298         for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
1299             unsigned mb_type;
1300             sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
1301
1302             if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1303                 ((get_bits_count(&h->gb) & 7) == 0 ||
1304                  show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1305                 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1306                 h->gb.size_in_bits = 8 * buf_size;
1307
1308                 if (svq3_decode_slice_header(avctx))
1309                     return -1;
1310
1311                 /* TODO: support s->mb_skip_run */
1312             }
1313
1314             mb_type = svq3_get_ue_golomb(&h->gb);
1315
1316             if (h->pict_type == AV_PICTURE_TYPE_I)
1317                 mb_type += 8;
1318             else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1319                 mb_type += 4;
1320             if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1321                 av_log(h->avctx, AV_LOG_ERROR,
1322                        "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
1323                 return -1;
1324             }
1325
1326             if (mb_type != 0 || sl->cbp)
1327                 ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
1328
1329             if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1330                 h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
1331                     (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1332         }
1333
1334         ff_draw_horiz_band(avctx, &s->cur_pic->f,
1335                            s->last_pic->f.data[0] ? &s->last_pic->f : NULL,
1336                            16 * sl->mb_y, 16, h->picture_structure, 0,
1337                            h->low_delay);
1338     }
1339
1340     left = buf_size*8 - get_bits_count(&h->gb);
1341
1342     if (sl->mb_y != h->mb_height || sl->mb_x != h->mb_width) {
1343         av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, sl->mb_y, sl->mb_x, left);
1344         //av_hex_dump(stderr, buf+buf_size-8, 8);
1345     }
1346
1347     if (left < 0) {
1348         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1349         return -1;
1350     }
1351
1352     if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1353         ret = av_frame_ref(data, &s->cur_pic->f);
1354     else if (s->last_pic->f.data[0])
1355         ret = av_frame_ref(data, &s->last_pic->f);
1356     if (ret < 0)
1357         return ret;
1358
1359     /* Do not output the last pic after seeking. */
1360     if (s->last_pic->f.data[0] || h->low_delay)
1361         *got_frame = 1;
1362
1363     if (h->pict_type != AV_PICTURE_TYPE_B) {
1364         FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1365     } else {
1366         av_frame_unref(&s->cur_pic->f);
1367     }
1368
1369     return buf_size;
1370 }
1371
1372 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1373 {
1374     SVQ3Context *s = avctx->priv_data;
1375     H264Context *h = &s->h;
1376
1377     free_picture(avctx, s->cur_pic);
1378     free_picture(avctx, s->next_pic);
1379     free_picture(avctx, s->last_pic);
1380     av_freep(&s->cur_pic);
1381     av_freep(&s->next_pic);
1382     av_freep(&s->last_pic);
1383
1384     av_frame_unref(&h->cur_pic.f);
1385
1386     ff_h264_free_context(h);
1387
1388     av_freep(&s->buf);
1389     s->buf_size = 0;
1390
1391     return 0;
1392 }
1393
1394 AVCodec ff_svq3_decoder = {
1395     .name           = "svq3",
1396     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1397     .type           = AVMEDIA_TYPE_VIDEO,
1398     .id             = AV_CODEC_ID_SVQ3,
1399     .priv_data_size = sizeof(SVQ3Context),
1400     .init           = svq3_decode_init,
1401     .close          = svq3_decode_end,
1402     .decode         = svq3_decode_frame,
1403     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND |
1404                       CODEC_CAP_DR1             |
1405                       CODEC_CAP_DELAY,
1406     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1407                                                      AV_PIX_FMT_NONE},
1408 };