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

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