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

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