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

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