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