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 has_watermark;
  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 & AV_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->has_watermark)
 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     s->cur_pic->f  = av_frame_alloc();
 894     s->last_pic->f = av_frame_alloc();
 895     s->next_pic->f = av_frame_alloc();
 896     if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
 897         return AVERROR(ENOMEM);
 898
 899     if ((ret = ff_h264_decode_init(avctx)) < 0)
 900         goto fail;
 901
 902     // we will overwrite it later during decoding
 903     av_frame_free(&h->cur_pic.f);
 904
 905     av_frame_free(&h->last_pic_for_ec.f);
 906
 907     ff_h264dsp_init(&h->h264dsp, 8, 1);
 908     av_assert0(h->sps.bit_depth_chroma == 0);
 909     ff_h264_pred_init(&h->hpc, AV_CODEC_ID_SVQ3, 8, 1);
 910     ff_videodsp_init(&h->vdsp, 8);
 911
 912     memset(h->pps.scaling_matrix4, 16, 6 * 16 * sizeof(uint8_t));
 913     memset(h->pps.scaling_matrix8, 16, 2 * 64 * sizeof(uint8_t));
 914
 915     avctx->bits_per_raw_sample = 8;
 916     h->sps.bit_depth_luma = 8;
 917     h->chroma_format_idc = 1;
 918
 919     ff_hpeldsp_init(&s->hdsp, avctx->flags);
 920     ff_tpeldsp_init(&s->tdsp);
 921
 922     sl = h->slice_ctx;
 923
 924     h->flags           = avctx->flags;
 925     sl->is_complex     = 1;
 926     h->sps.chroma_format_idc = 1;
 927     h->picture_structure = PICT_FRAME;
 928     avctx->pix_fmt     = AV_PIX_FMT_YUVJ420P;
 929     avctx->color_range = AVCOL_RANGE_JPEG;
 930
 931     h->slice_ctx[0].chroma_qp[0] = h->slice_ctx[0].chroma_qp[1] = 4;
 932     h->chroma_x_shift = h->chroma_y_shift = 1;
 933
 934     s->halfpel_flag  = 1;
 935     s->thirdpel_flag = 1;
 936     s->has_watermark = 0;
 937
 938     /* prowl for the "SEQH" marker in the extradata */
 939     extradata     = (unsigned char *)avctx->extradata;
 940     extradata_end = avctx->extradata + avctx->extradata_size;
 941     if (extradata) {
 942         for (m = 0; m + 8 < avctx->extradata_size; m++) {
 943             if (!memcmp(extradata, "SEQH", 4)) {
 944                 marker_found = 1;
 945                 break;
 946             }
 947             extradata++;
 948         }
 949     }
 950
 951     /* if a match was found, parse the extra data */
 952     if (marker_found) {
 953         GetBitContext gb;
 954         int frame_size_code;
 955         int unk0, unk1, unk2, unk3, unk4;
 956
 957         size = AV_RB32(&extradata[4]);
 958         if (size > extradata_end - extradata - 8) {
 959             ret = AVERROR_INVALIDDATA;
 960             goto fail;
 961         }
 962         init_get_bits(&gb, extradata + 8, size * 8);
 963
 964         /* 'frame size code' and optional 'width, height' */
 965         frame_size_code = get_bits(&gb, 3);
 966         switch (frame_size_code) {
 967         case 0:
 968             avctx->width  = 160;
 969             avctx->height = 120;
 970             break;
 971         case 1:
 972             avctx->width  = 128;
 973             avctx->height =  96;
 974             break;
 975         case 2:
 976             avctx->width  = 176;
 977             avctx->height = 144;
 978             break;
 979         case 3:
 980             avctx->width  = 352;
 981             avctx->height = 288;
 982             break;
 983         case 4:
 984             avctx->width  = 704;
 985             avctx->height = 576;
 986             break;
 987         case 5:
 988             avctx->width  = 240;
 989             avctx->height = 180;
 990             break;
 991         case 6:
 992             avctx->width  = 320;
 993             avctx->height = 240;
 994             break;
 995         case 7:
 996             avctx->width  = get_bits(&gb, 12);
 997             avctx->height = get_bits(&gb, 12);
 998             break;
 999         }
1000
1001         s->halfpel_flag  = get_bits1(&gb);
1002         s->thirdpel_flag = get_bits1(&gb);
1003
1004         /* unknown fields */
1005         unk0 = get_bits1(&gb);
1006         unk1 = get_bits1(&gb);
1007         unk2 = get_bits1(&gb);
1008         unk3 = get_bits1(&gb);
1009
1010         h->low_delay = get_bits1(&gb);
1011
1012         /* unknown field */
1013         unk4 = get_bits1(&gb);
1014
1015         av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1016                unk0, unk1, unk2, unk3, unk4);
1017
1018         if (skip_1stop_8data_bits(&gb) < 0) {
1019             ret = AVERROR_INVALIDDATA;
1020             goto fail;
1021         }
1022
1023         s->has_watermark  = get_bits1(&gb);
1024         avctx->has_b_frames = !h->low_delay;
1025         if (s->has_watermark) {
1026 #if CONFIG_ZLIB
1027             unsigned watermark_width  = svq3_get_ue_golomb(&gb);
1028             unsigned watermark_height = svq3_get_ue_golomb(&gb);
1029             int u1                    = svq3_get_ue_golomb(&gb);
1030             int u2                    = get_bits(&gb, 8);
1031             int u3                    = get_bits(&gb, 2);
1032             int u4                    = svq3_get_ue_golomb(&gb);
1033             unsigned long buf_len     = watermark_width *
1034                                         watermark_height * 4;
1035             int offset                = get_bits_count(&gb) + 7 >> 3;
1036             uint8_t *buf;
1037
1038             if (watermark_height <= 0 ||
1039                 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height) {
1040                 ret = -1;
1041                 goto fail;
1042             }
1043
1044             buf = av_malloc(buf_len);
1045             if (!buf) {
1046                 ret = AVERROR(ENOMEM);
1047                 goto fail;
1048             }
1049             av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1050                    watermark_width, watermark_height);
1051             av_log(avctx, AV_LOG_DEBUG,
1052                    "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1053                    u1, u2, u3, u4, offset);
1054             if (uncompress(buf, &buf_len, extradata + 8 + offset,
1055                            size - offset) != Z_OK) {
1056                 av_log(avctx, AV_LOG_ERROR,
1057                        "could not uncompress watermark logo\n");
1058                 av_free(buf);
1059                 ret = -1;
1060                 goto fail;
1061             }
1062             s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1063             s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1064             av_log(avctx, AV_LOG_DEBUG,
1065                    "watermark key %#"PRIx32"\n", s->watermark_key);
1066             av_free(buf);
1067 #else
1068             av_log(avctx, AV_LOG_ERROR,
1069                    "this svq3 file contains watermark which need zlib support compiled in\n");
1070             ret = -1;
1071             goto fail;
1072 #endif
1073         }
1074     }
1075
1076     h->width  = avctx->width;
1077     h->height = avctx->height;
1078     h->mb_width  = (h->width + 15) / 16;
1079     h->mb_height = (h->height + 15) / 16;
1080     h->mb_stride = h->mb_width + 1;
1081     h->mb_num    = h->mb_width * h->mb_height;
1082     h->b_stride = 4 * h->mb_width;
1083     s->h_edge_pos = h->mb_width * 16;
1084     s->v_edge_pos = h->mb_height * 16;
1085
1086     if ((ret = ff_h264_alloc_tables(h)) < 0) {
1087         av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1088         goto fail;
1089     }
1090
1091     return 0;
1092 fail:
1093     svq3_decode_end(avctx);
1094     return ret;
1095 }
1096
1097 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1098 {
1099     int i;
1100     for (i = 0; i < 2; i++) {
1101         av_buffer_unref(&pic->motion_val_buf[i]);
1102         av_buffer_unref(&pic->ref_index_buf[i]);
1103     }
1104     av_buffer_unref(&pic->mb_type_buf);
1105
1106     av_frame_unref(pic->f);
1107 }
1108
1109 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1110 {
1111     SVQ3Context *s = avctx->priv_data;
1112     H264Context *h = &s->h;
1113     H264SliceContext *sl = &h->slice_ctx[0];
1114     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
1115     const int mb_array_size = h->mb_stride * h->mb_height;
1116     const int b4_stride     = h->mb_width * 4 + 1;
1117     const int b4_array_size = b4_stride * h->mb_height * 4;
1118     int ret;
1119
1120     if (!pic->motion_val_buf[0]) {
1121         int i;
1122
1123         pic->mb_type_buf = av_buffer_allocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1124         if (!pic->mb_type_buf)
1125             return AVERROR(ENOMEM);
1126         pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
1127
1128         for (i = 0; i < 2; i++) {
1129             pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1130             pic->ref_index_buf[i]  = av_buffer_allocz(4 * mb_array_size);
1131             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1132                 ret = AVERROR(ENOMEM);
1133                 goto fail;
1134             }
1135
1136             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1137             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
1138         }
1139     }
1140     pic->reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1141
1142     ret = ff_get_buffer(avctx, pic->f,
1143                         pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1144     if (ret < 0)
1145         goto fail;
1146
1147     if (!sl->edge_emu_buffer) {
1148         sl->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1149         if (!sl->edge_emu_buffer)
1150             return AVERROR(ENOMEM);
1151     }
1152
1153     sl->linesize   = pic->f->linesize[0];
1154     sl->uvlinesize = pic->f->linesize[1];
1155
1156     return 0;
1157 fail:
1158     free_picture(avctx, pic);
1159     return ret;
1160 }
1161
1162 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1163                              int *got_frame, AVPacket *avpkt)
1164 {
1165     SVQ3Context *s     = avctx->priv_data;
1166     H264Context *h     = &s->h;
1167     H264SliceContext *sl = &h->slice_ctx[0];
1168     int buf_size       = avpkt->size;
1169     int left;
1170     uint8_t *buf;
1171     int ret, m, i;
1172
1173     /* special case for last picture */
1174     if (buf_size == 0) {
1175         if (s->next_pic->f->data[0] && !h->low_delay && !s->last_frame_output) {
1176             ret = av_frame_ref(data, s->next_pic->f);
1177             if (ret < 0)
1178                 return ret;
1179             s->last_frame_output = 1;
1180             *got_frame          = 1;
1181         }
1182         return 0;
1183     }
1184
1185     sl->mb_x = sl->mb_y = sl->mb_xy = 0;
1186
1187     if (s->watermark_key) {
1188         av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1189         if (!s->buf)
1190             return AVERROR(ENOMEM);
1191         memcpy(s->buf, avpkt->data, buf_size);
1192         buf = s->buf;
1193     } else {
1194         buf = avpkt->data;
1195     }
1196
1197     init_get_bits(&h->gb, buf, 8 * buf_size);
1198
1199     if (svq3_decode_slice_header(avctx))
1200         return -1;
1201
1202     h->pict_type = sl->slice_type;
1203
1204     if (h->pict_type != AV_PICTURE_TYPE_B)
1205         FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1206
1207     av_frame_unref(s->cur_pic->f);
1208
1209     /* for skipping the frame */
1210     s->cur_pic->f->pict_type = h->pict_type;
1211     s->cur_pic->f->key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1212
1213     ret = get_buffer(avctx, s->cur_pic);
1214     if (ret < 0)
1215         return ret;
1216
1217     h->cur_pic_ptr = s->cur_pic;
1218     h->cur_pic     = *s->cur_pic;
1219
1220     for (i = 0; i < 16; i++) {
1221         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1222         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->linesize * ((scan8[i] - scan8[0]) >> 3);
1223     }
1224     for (i = 0; i < 16; i++) {
1225         h->block_offset[16 + i]      =
1226         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1227         h->block_offset[48 + 16 + i] =
1228         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * sl->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1229     }
1230
1231     if (h->pict_type != AV_PICTURE_TYPE_I) {
1232         if (!s->last_pic->f->data[0]) {
1233             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1234             av_frame_unref(s->last_pic->f);
1235             ret = get_buffer(avctx, s->last_pic);
1236             if (ret < 0)
1237                 return ret;
1238             memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1239             memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1240                    s->last_pic->f->linesize[1]);
1241             memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1242                    s->last_pic->f->linesize[2]);
1243         }
1244
1245         if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1246             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1247             av_frame_unref(s->next_pic->f);
1248             ret = get_buffer(avctx, s->next_pic);
1249             if (ret < 0)
1250                 return ret;
1251             memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1252             memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1253                    s->next_pic->f->linesize[1]);
1254             memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1255                    s->next_pic->f->linesize[2]);
1256         }
1257     }
1258
1259     if (avctx->debug & FF_DEBUG_PICT_INFO)
1260         av_log(h->avctx, AV_LOG_DEBUG,
1261                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1262                av_get_picture_type_char(h->pict_type),
1263                s->halfpel_flag, s->thirdpel_flag,
1264                s->adaptive_quant, h->slice_ctx[0].qscale, sl->slice_num);
1265
1266     if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1267         avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1268         avctx->skip_frame >= AVDISCARD_ALL)
1269         return 0;
1270
1271     if (s->next_p_frame_damaged) {
1272         if (h->pict_type == AV_PICTURE_TYPE_B)
1273             return 0;
1274         else
1275             s->next_p_frame_damaged = 0;
1276     }
1277
1278     if (h->pict_type == AV_PICTURE_TYPE_B) {
1279         h->frame_num_offset = sl->slice_num - h->prev_frame_num;
1280
1281         if (h->frame_num_offset < 0)
1282             h->frame_num_offset += 256;
1283         if (h->frame_num_offset == 0 ||
1284             h->frame_num_offset >= h->prev_frame_num_offset) {
1285             av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1286             return -1;
1287         }
1288     } else {
1289         h->prev_frame_num        = h->frame_num;
1290         h->frame_num             = sl->slice_num;
1291         h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1292
1293         if (h->prev_frame_num_offset < 0)
1294             h->prev_frame_num_offset += 256;
1295     }
1296
1297     for (m = 0; m < 2; m++) {
1298         int i;
1299         for (i = 0; i < 4; i++) {
1300             int j;
1301             for (j = -1; j < 4; j++)
1302                 sl->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1303             if (i < 3)
1304                 sl->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1305         }
1306     }
1307
1308     for (sl->mb_y = 0; sl->mb_y < h->mb_height; sl->mb_y++) {
1309         for (sl->mb_x = 0; sl->mb_x < h->mb_width; sl->mb_x++) {
1310             unsigned mb_type;
1311             sl->mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
1312
1313             if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1314                 ((get_bits_count(&h->gb) & 7) == 0 ||
1315                  show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1316                 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1317                 h->gb.size_in_bits = 8 * buf_size;
1318
1319                 if (svq3_decode_slice_header(avctx))
1320                     return -1;
1321
1322                 /* TODO: support s->mb_skip_run */
1323             }
1324
1325             mb_type = svq3_get_ue_golomb(&h->gb);
1326
1327             if (h->pict_type == AV_PICTURE_TYPE_I)
1328                 mb_type += 8;
1329             else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1330                 mb_type += 4;
1331             if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1332                 av_log(h->avctx, AV_LOG_ERROR,
1333                        "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
1334                 return -1;
1335             }
1336
1337             if (mb_type != 0 || sl->cbp)
1338                 ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
1339
1340             if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1341                 h->cur_pic.mb_type[sl->mb_x + sl->mb_y * h->mb_stride] =
1342                     (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1343         }
1344
1345         ff_draw_horiz_band(avctx, s->cur_pic->f,
1346                            s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1347                            16 * sl->mb_y, 16, h->picture_structure, 0,
1348                            h->low_delay);
1349     }
1350
1351     left = buf_size*8 - get_bits_count(&h->gb);
1352
1353     if (sl->mb_y != h->mb_height || sl->mb_x != h->mb_width) {
1354         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);
1355         //av_hex_dump(stderr, buf+buf_size-8, 8);
1356     }
1357
1358     if (left < 0) {
1359         av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1360         return -1;
1361     }
1362
1363     if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1364         ret = av_frame_ref(data, s->cur_pic->f);
1365     else if (s->last_pic->f->data[0])
1366         ret = av_frame_ref(data, s->last_pic->f);
1367     if (ret < 0)
1368         return ret;
1369
1370     /* Do not output the last pic after seeking. */
1371     if (s->last_pic->f->data[0] || h->low_delay)
1372         *got_frame = 1;
1373
1374     if (h->pict_type != AV_PICTURE_TYPE_B) {
1375         FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1376     } else {
1377         av_frame_unref(s->cur_pic->f);
1378     }
1379
1380     return buf_size;
1381 }
1382
1383 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1384 {
1385     SVQ3Context *s = avctx->priv_data;
1386     H264Context *h = &s->h;
1387
1388     free_picture(avctx, s->cur_pic);
1389     free_picture(avctx, s->next_pic);
1390     free_picture(avctx, s->last_pic);
1391     av_frame_free(&s->cur_pic->f);
1392     av_frame_free(&s->next_pic->f);
1393     av_frame_free(&s->last_pic->f);
1394     av_freep(&s->cur_pic);
1395     av_freep(&s->next_pic);
1396     av_freep(&s->last_pic);
1397
1398     memset(&h->cur_pic, 0, sizeof(h->cur_pic));
1399
1400     ff_h264_free_context(h);
1401
1402     av_freep(&s->buf);
1403     s->buf_size = 0;
1404
1405     return 0;
1406 }
1407
1408 AVCodec ff_svq3_decoder = {
1409     .name           = "svq3",
1410     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1411     .type           = AVMEDIA_TYPE_VIDEO,
1412     .id             = AV_CODEC_ID_SVQ3,
1413     .priv_data_size = sizeof(SVQ3Context),
1414     .init           = svq3_decode_init,
1415     .close          = svq3_decode_end,
1416     .decode         = svq3_decode_frame,
1417     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1418                       AV_CODEC_CAP_DR1             |
1419                       AV_CODEC_CAP_DELAY,
1420     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1421                                                      AV_PIX_FMT_NONE},
1422 };