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(DCTELEM *output, DCTELEM *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, DCTELEM *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, DCTELEM *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, sign, vlc, limit;
 220     const int intra           = 3 * type >> 2;
 221     const uint8_t *const scan = scan_patterns[type];
 222
 223     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
 224         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
 225             if (vlc == INVALID_VLC)
 226                 return -1;
 227
 228             sign = (vlc & 0x1) - 1;
 229             vlc  = vlc + 1 >> 1;
 230
 231             if (type == 3) {
 232                 if (vlc < 3) {
 233                     run   = 0;
 234                     level = vlc;
 235                 } else if (vlc < 4) {
 236                     run   = 1;
 237                     level = 1;
 238                 } else {
 239                     run   = vlc & 0x3;
 240                     level = (vlc + 9 >> 2) - run;
 241                 }
 242             } else {
 243                 if (vlc < 16) {
 244                     run   = svq3_dct_tables[intra][vlc].run;
 245                     level = svq3_dct_tables[intra][vlc].level;
 246                 } else if (intra) {
 247                     run   = vlc & 0x7;
 248                     level = (vlc >> 3) +
 249                             ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 250                 } else {
 251                     run   = vlc & 0xF;
 252                     level = (vlc >> 4) +
 253                             ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 254                 }
 255             }
 256
 257             if ((index += run) >= limit)
 258                 return -1;
 259
 260             block[scan[index]] = (level ^ sign) - sign;
 261         }
 262
 263         if (type != 2) {
 264             break;
 265         }
 266     }
 267
 268     return 0;
 269 }
 270
 271 static inline void svq3_mc_dir_part(MpegEncContext *s,
 272                                     int x, int y, int width, int height,
 273                                     int mx, int my, int dxy,
 274                                     int thirdpel, int dir, int avg)
 275 {
 276     const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
 277     uint8_t *src, *dest;
 278     int i, emu = 0;
 279     int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
 280
 281     mx += x;
 282     my += y;
 283
 284     if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
 285         my < 0 || my >= s->v_edge_pos - height - 1) {
 286         if ((s->flags & CODEC_FLAG_EMU_EDGE))
 287             emu = 1;
 288
 289         mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
 290         my = av_clip(my, -16, s->v_edge_pos - height + 15);
 291     }
 292
 293     /* form component predictions */
 294     dest = s->current_picture.f.data[0] + x + y * s->linesize;
 295     src  = pic->f.data[0] + mx + my * s->linesize;
 296
 297     if (emu) {
 298         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize,
 299                                 width + 1, height + 1,
 300                                 mx, my, s->h_edge_pos, s->v_edge_pos);
 301         src = s->edge_emu_buffer;
 302     }
 303     if (thirdpel)
 304         (avg ? s->dsp.avg_tpel_pixels_tab
 305              : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize,
 306                                                 width, height);
 307     else
 308         (avg ? s->dsp.avg_pixels_tab
 309              : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize,
 310                                                       height);
 311
 312     if (!(s->flags & CODEC_FLAG_GRAY)) {
 313         mx     = mx + (mx < (int) x) >> 1;
 314         my     = my + (my < (int) y) >> 1;
 315         width  = width  >> 1;
 316         height = height >> 1;
 317         blocksize++;
 318
 319         for (i = 1; i < 3; i++) {
 320             dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
 321             src  = pic->f.data[i] + mx + my * s->uvlinesize;
 322
 323             if (emu) {
 324                 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize,
 325                                         width + 1, height + 1,
 326                                         mx, my, (s->h_edge_pos >> 1),
 327                                         s->v_edge_pos >> 1);
 328                 src = s->edge_emu_buffer;
 329             }
 330             if (thirdpel)
 331                 (avg ? s->dsp.avg_tpel_pixels_tab
 332                      : s->dsp.put_tpel_pixels_tab)[dxy](dest, src,
 333                                                         s->uvlinesize,
 334                                                         width, height);
 335             else
 336                 (avg ? s->dsp.avg_pixels_tab
 337                      : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
 338                                                               s->uvlinesize,
 339                                                               height);
 340         }
 341     }
 342 }
 343
 344 static inline int svq3_mc_dir(H264Context *h, int size, int mode,
 345                               int dir, int avg)
 346 {
 347     int i, j, k, mx, my, dx, dy, x, y;
 348     MpegEncContext *const s = (MpegEncContext *)h;
 349     const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 350     const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
 351     const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
 352     const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
 353     const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;
 354
 355     for (i = 0; i < 16; i += part_height)
 356         for (j = 0; j < 16; j += part_width) {
 357             const int b_xy = (4 * s->mb_x + (j >> 2)) +
 358                              (4 * s->mb_y + (i >> 2)) * h->b_stride;
 359             int dxy;
 360             x = 16 * s->mb_x + j;
 361             y = 16 * s->mb_y + i;
 362             k = (j >> 2 & 1) + (i >> 1 & 2) +
 363                 (j >> 1 & 4) + (i      & 8);
 364
 365             if (mode != PREDICT_MODE) {
 366                 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
 367             } else {
 368                 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
 369                 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
 370
 371                 if (dir == 0) {
 372                     mx = mx * h->frame_num_offset /
 373                          h->prev_frame_num_offset + 1 >> 1;
 374                     my = my * h->frame_num_offset /
 375                          h->prev_frame_num_offset + 1 >> 1;
 376                 } else {
 377                     mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
 378                          h->prev_frame_num_offset + 1 >> 1;
 379                     my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
 380                          h->prev_frame_num_offset + 1 >> 1;
 381                 }
 382             }
 383
 384             /* clip motion vector prediction to frame border */
 385             mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
 386             my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
 387
 388             /* get (optional) motion vector differential */
 389             if (mode == PREDICT_MODE) {
 390                 dx = dy = 0;
 391             } else {
 392                 dy = svq3_get_se_golomb(&s->gb);
 393                 dx = svq3_get_se_golomb(&s->gb);
 394
 395                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 396                     av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 397                     return -1;
 398                 }
 399             }
 400
 401             /* compute motion vector */
 402             if (mode == THIRDPEL_MODE) {
 403                 int fx, fy;
 404                 mx  = (mx + 1 >> 1) + dx;
 405                 my  = (my + 1 >> 1) + dy;
 406                 fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
 407                 fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
 408                 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
 409
 410                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 411                                  fx, fy, dxy, 1, dir, avg);
 412                 mx += mx;
 413                 my += my;
 414             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 415                 mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
 416                 my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
 417                 dxy = (mx & 1) + 2 * (my & 1);
 418
 419                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 420                                  mx >> 1, my >> 1, dxy, 0, dir, avg);
 421                 mx *= 3;
 422                 my *= 3;
 423             } else {
 424                 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
 425                 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
 426
 427                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 428                                  mx, my, 0, 0, dir, avg);
 429                 mx *= 6;
 430                 my *= 6;
 431             }
 432
 433             /* update mv_cache */
 434             if (mode != PREDICT_MODE) {
 435                 int32_t mv = pack16to32(mx, my);
 436
 437                 if (part_height == 8 && i < 8) {
 438                     AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
 439
 440                     if (part_width == 8 && j < 8)
 441                         AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
 442                 }
 443                 if (part_width == 8 && j < 8)
 444                     AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
 445                 if (part_width == 4 || part_height == 4)
 446                     AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
 447             }
 448
 449             /* write back motion vectors */
 450             fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
 451                            part_width >> 2, part_height >> 2, h->b_stride,
 452                            pack16to32(mx, my), 4);
 453         }
 454
 455     return 0;
 456 }
 457
 458 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
 459 {
 460     H264Context *h = &svq3->h;
 461     int i, j, k, m, dir, mode;
 462     int cbp = 0;
 463     uint32_t vlc;
 464     int8_t *top, *left;
 465     MpegEncContext *const s = (MpegEncContext *)h;
 466     const int mb_xy         = h->mb_xy;
 467     const int b_xy          = 4 * s->mb_x + 4 * s->mb_y * h->b_stride;
 468
 469     h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 470     h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 471     h->topright_samples_available = 0xFFFF;
 472
 473     if (mb_type == 0) {           /* SKIP */
 474         if (s->pict_type == AV_PICTURE_TYPE_P ||
 475             s->next_picture.f.mb_type[mb_xy] == -1) {
 476             svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 477                              0, 0, 0, 0, 0, 0);
 478
 479             if (s->pict_type == AV_PICTURE_TYPE_B)
 480                 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 481                                  0, 0, 0, 0, 1, 1);
 482
 483             mb_type = MB_TYPE_SKIP;
 484         } else {
 485             mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
 486             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
 487                 return -1;
 488             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
 489                 return -1;
 490
 491             mb_type = MB_TYPE_16x16;
 492         }
 493     } else if (mb_type < 8) {     /* INTER */
 494         if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1(&s->gb))
 495             mode = THIRDPEL_MODE;
 496         else if (svq3->halfpel_flag &&
 497                  svq3->thirdpel_flag == !get_bits1(&s->gb))
 498             mode = HALFPEL_MODE;
 499         else
 500             mode = FULLPEL_MODE;
 501
 502         /* fill caches */
 503         /* note ref_cache should contain here:
 504          *  ????????
 505          *  ???11111
 506          *  N??11111
 507          *  N??11111
 508          *  N??11111
 509          */
 510
 511         for (m = 0; m < 2; m++) {
 512             if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
 513                 for (i = 0; i < 4; i++)
 514                     AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
 515                               s->current_picture.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
 516             } else {
 517                 for (i = 0; i < 4; i++)
 518                     AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
 519             }
 520             if (s->mb_y > 0) {
 521                 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
 522                        s->current_picture.f.motion_val[m][b_xy - h->b_stride],
 523                        4 * 2 * sizeof(int16_t));
 524                 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
 525                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 526
 527                 if (s->mb_x < s->mb_width - 1) {
 528                     AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
 529                               s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
 530                     h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
 531                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
 532                          h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
 533                 } else
 534                     h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
 535                 if (s->mb_x > 0) {
 536                     AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
 537                               s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
 538                     h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
 539                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
 540                 } else
 541                     h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
 542             } else
 543                 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
 544                        PART_NOT_AVAILABLE, 8);
 545
 546             if (s->pict_type != AV_PICTURE_TYPE_B)
 547                 break;
 548         }
 549
 550         /* decode motion vector(s) and form prediction(s) */
 551         if (s->pict_type == AV_PICTURE_TYPE_P) {
 552             if (svq3_mc_dir(h, mb_type - 1, mode, 0, 0) < 0)
 553                 return -1;
 554         } else {        /* AV_PICTURE_TYPE_B */
 555             if (mb_type != 2)
 556                 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
 557                     return -1;
 558             else
 559                 for (i = 0; i < 4; i++)
 560                     memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
 561                            0, 4 * 2 * sizeof(int16_t));
 562             if (mb_type != 1)
 563                 if (svq3_mc_dir(h, 0, mode, 1, mb_type == 3) < 0)
 564                     return -1;
 565             else
 566                 for (i = 0; i < 4; i++)
 567                     memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
 568                            0, 4 * 2 * sizeof(int16_t));
 569         }
 570
 571         mb_type = MB_TYPE_16x16;
 572     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 573         memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
 574
 575         if (mb_type == 8) {
 576             if (s->mb_x > 0) {
 577                 for (i = 0; i < 4; i++)
 578                     h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
 579                 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
 580                     h->left_samples_available = 0x5F5F;
 581             }
 582             if (s->mb_y > 0) {
 583                 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 0];
 584                 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 1];
 585                 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 2];
 586                 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 3];
 587
 588                 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
 589                     h->top_samples_available = 0x33FF;
 590             }
 591
 592             /* decode prediction codes for luma blocks */
 593             for (i = 0; i < 16; i += 2) {
 594                 vlc = svq3_get_ue_golomb(&s->gb);
 595
 596                 if (vlc >= 25) {
 597                     av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
 598                     return -1;
 599                 }
 600
 601                 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 602                 top  = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 603
 604                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 605                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 606
 607                 if (left[1] == -1 || left[2] == -1) {
 608                     av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
 609                     return -1;
 610                 }
 611             }
 612         } else {    /* mb_type == 33, DC_128_PRED block type */
 613             for (i = 0; i < 4; i++)
 614                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
 615         }
 616
 617         write_back_intra_pred_mode(h);
 618
 619         if (mb_type == 8) {
 620             ff_h264_check_intra4x4_pred_mode(h);
 621
 622             h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 623             h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 624         } else {
 625             for (i = 0; i < 4; i++)
 626                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
 627
 628             h->top_samples_available  = 0x33FF;
 629             h->left_samples_available = 0x5F5F;
 630         }
 631
 632         mb_type = MB_TYPE_INTRA4x4;
 633     } else {                      /* INTRA16x16 */
 634         dir = i_mb_type_info[mb_type - 8].pred_mode;
 635         dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
 636
 637         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
 638             av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
 639             return -1;
 640         }
 641
 642         cbp     = i_mb_type_info[mb_type - 8].cbp;
 643         mb_type = MB_TYPE_INTRA16x16;
 644     }
 645
 646     if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
 647         for (i = 0; i < 4; i++)
 648             memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
 649                    0, 4 * 2 * sizeof(int16_t));
 650         if (s->pict_type == AV_PICTURE_TYPE_B) {
 651             for (i = 0; i < 4; i++)
 652                 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
 653                        0, 4 * 2 * sizeof(int16_t));
 654         }
 655     }
 656     if (!IS_INTRA4x4(mb_type)) {
 657         memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
 658     }
 659     if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
 660         memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
 661         s->dsp.clear_blocks(h->mb +   0);
 662         s->dsp.clear_blocks(h->mb + 384);
 663     }
 664
 665     if (!IS_INTRA16x16(mb_type) &&
 666         (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 667         if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48) {
 668             av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
 669             return -1;
 670         }
 671
 672         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
 673                                 : golomb_to_inter_cbp[vlc];
 674     }
 675     if (IS_INTRA16x16(mb_type) ||
 676         (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 677         s->qscale += svq3_get_se_golomb(&s->gb);
 678
 679         if (s->qscale > 31u) {
 680             av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 681             return -1;
 682         }
 683     }
 684     if (IS_INTRA16x16(mb_type)) {
 685         AV_ZERO128(h->mb_luma_dc[0] + 0);
 686         AV_ZERO128(h->mb_luma_dc[0] + 8);
 687         if (svq3_decode_block(&s->gb, h->mb_luma_dc[0], 0, 1)) {
 688             av_log(h->s.avctx, AV_LOG_ERROR,
 689                    "error while decoding intra luma dc\n");
 690             return -1;
 691         }
 692     }
 693
 694     if (cbp) {
 695         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 696         const int type  = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 697
 698         for (i = 0; i < 4; i++)
 699             if ((cbp & (1 << i))) {
 700                 for (j = 0; j < 4; j++) {
 701                     k = index ? (1 * (j & 1) + 2 * (i & 1) +
 702                                  2 * (j & 2) + 4 * (i & 2))
 703                               : (4 * i + j);
 704                     h->non_zero_count_cache[scan8[k]] = 1;
 705
 706                     if (svq3_decode_block(&s->gb, &h->mb[16 * k], index, type)) {
 707                         av_log(h->s.avctx, AV_LOG_ERROR,
 708                                "error while decoding block\n");
 709                         return -1;
 710                     }
 711                 }
 712             }
 713
 714         if ((cbp & 0x30)) {
 715             for (i = 1; i < 3; ++i)
 716                 if (svq3_decode_block(&s->gb, &h->mb[16 * 16 * i], 0, 3)) {
 717                     av_log(h->s.avctx, AV_LOG_ERROR,
 718                            "error while decoding chroma dc block\n");
 719                     return -1;
 720                 }
 721
 722             if ((cbp & 0x20)) {
 723                 for (i = 1; i < 3; i++) {
 724                     for (j = 0; j < 4; j++) {
 725                         k                                 = 16 * i + j;
 726                         h->non_zero_count_cache[scan8[k]] = 1;
 727
 728                         if (svq3_decode_block(&s->gb, &h->mb[16 * k], 1, 1)) {
 729                             av_log(h->s.avctx, AV_LOG_ERROR,
 730                                    "error while decoding chroma ac block\n");
 731                             return -1;
 732                         }
 733                     }
 734                 }
 735             }
 736         }
 737     }
 738
 739     h->cbp                              = cbp;
 740     s->current_picture.f.mb_type[mb_xy] = mb_type;
 741
 742     if (IS_INTRA(mb_type))
 743         h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
 744
 745     return 0;
 746 }
 747
 748 static int svq3_decode_slice_header(AVCodecContext *avctx)
 749 {
 750     SVQ3Context *svq3 = avctx->priv_data;
 751     H264Context *h    = &svq3->h;
 752     MpegEncContext *s = &h->s;
 753     const int mb_xy   = h->mb_xy;
 754     int i, header;
 755
 756     header = get_bits(&s->gb, 8);
 757
 758     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
 759         /* TODO: what? */
 760         av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
 761         return -1;
 762     } else {
 763         int length = header >> 5 & 3;
 764
 765         svq3->next_slice_index = get_bits_count(&s->gb) +
 766                                  8 * show_bits(&s->gb, 8 * length) +
 767                                  8 * length;
 768
 769         if (svq3->next_slice_index > s->gb.size_in_bits) {
 770             av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
 771             return -1;
 772         }
 773
 774         s->gb.size_in_bits = svq3->next_slice_index - 8 * (length - 1);
 775         skip_bits(&s->gb, 8);
 776
 777         if (svq3->watermark_key) {
 778             uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1]);
 779             AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1],
 780                     header ^ svq3->watermark_key);
 781         }
 782         if (length > 0) {
 783             memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
 784                    &s->gb.buffer[s->gb.size_in_bits >> 3], length - 1);
 785         }
 786         skip_bits_long(&s->gb, 0);
 787     }
 788
 789     if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3) {
 790         av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
 791         return -1;
 792     }
 793
 794     h->slice_type = golomb_to_pict_type[i];
 795
 796     if ((header & 0x9F) == 2) {
 797         i              = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
 798         s->mb_skip_run = get_bits(&s->gb, i) -
 799                          (s->mb_y * s->mb_width + s->mb_x);
 800     } else {
 801         skip_bits1(&s->gb);
 802         s->mb_skip_run = 0;
 803     }
 804
 805     h->slice_num      = get_bits(&s->gb, 8);
 806     s->qscale         = get_bits(&s->gb, 5);
 807     s->adaptive_quant = get_bits1(&s->gb);
 808
 809     /* unknown fields */
 810     skip_bits1(&s->gb);
 811
 812     if (svq3->unknown_flag)
 813         skip_bits1(&s->gb);
 814
 815     skip_bits1(&s->gb);
 816     skip_bits(&s->gb, 2);
 817
 818     while (get_bits1(&s->gb))
 819         skip_bits(&s->gb, 8);
 820
 821     /* reset intra predictors and invalidate motion vector references */
 822     if (s->mb_x > 0) {
 823         memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
 824                -1, 4 * sizeof(int8_t));
 825         memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
 826                -1, 8 * sizeof(int8_t) * s->mb_x);
 827     }
 828     if (s->mb_y > 0) {
 829         memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_stride],
 830                -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
 831
 832         if (s->mb_x > 0)
 833             h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
 834     }
 835
 836     return 0;
 837 }
 838
 839 static av_cold int svq3_decode_init(AVCodecContext *avctx)
 840 {
 841     SVQ3Context *svq3 = avctx->priv_data;
 842     H264Context *h    = &svq3->h;
 843     MpegEncContext *s = &h->s;
 844     int m;
 845     unsigned char *extradata;
 846     unsigned char *extradata_end;
 847     unsigned int size;
 848     int marker_found = 0;
 849
 850     if (ff_h264_decode_init(avctx) < 0)
 851         return -1;
 852
 853     s->flags           = avctx->flags;
 854     s->flags2          = avctx->flags2;
 855     s->unrestricted_mv = 1;
 856     h->is_complex      = 1;
 857     avctx->pix_fmt     = avctx->codec->pix_fmts[0];
 858
 859     if (!s->context_initialized) {
 860         h->chroma_qp[0] = h->chroma_qp[1] = 4;
 861
 862         svq3->halfpel_flag  = 1;
 863         svq3->thirdpel_flag = 1;
 864         svq3->unknown_flag  = 0;
 865
 866         /* prowl for the "SEQH" marker in the extradata */
 867         extradata     = (unsigned char *)avctx->extradata;
 868         extradata_end = avctx->extradata + avctx->extradata_size;
 869         if (extradata) {
 870             for (m = 0; m + 8 < avctx->extradata_size; m++) {
 871                 if (!memcmp(extradata, "SEQH", 4)) {
 872                     marker_found = 1;
 873                     break;
 874                 }
 875                 extradata++;
 876             }
 877         }
 878
 879         /* if a match was found, parse the extra data */
 880         if (marker_found) {
 881             GetBitContext gb;
 882             int frame_size_code;
 883
 884             size = AV_RB32(&extradata[4]);
 885             if (size > extradata_end - extradata - 8)
 886                 return AVERROR_INVALIDDATA;
 887             init_get_bits(&gb, extradata + 8, size * 8);
 888
 889             /* 'frame size code' and optional 'width, height' */
 890             frame_size_code = get_bits(&gb, 3);
 891             switch (frame_size_code) {
 892             case 0:
 893                 avctx->width  = 160;
 894                 avctx->height = 120;
 895                 break;
 896             case 1:
 897                 avctx->width  = 128;
 898                 avctx->height =  96;
 899                 break;
 900             case 2:
 901                 avctx->width  = 176;
 902                 avctx->height = 144;
 903                 break;
 904             case 3:
 905                 avctx->width  = 352;
 906                 avctx->height = 288;
 907                 break;
 908             case 4:
 909                 avctx->width  = 704;
 910                 avctx->height = 576;
 911                 break;
 912             case 5:
 913                 avctx->width  = 240;
 914                 avctx->height = 180;
 915                 break;
 916             case 6:
 917                 avctx->width  = 320;
 918                 avctx->height = 240;
 919                 break;
 920             case 7:
 921                 avctx->width  = get_bits(&gb, 12);
 922                 avctx->height = get_bits(&gb, 12);
 923                 break;
 924             }
 925
 926             svq3->halfpel_flag  = get_bits1(&gb);
 927             svq3->thirdpel_flag = get_bits1(&gb);
 928
 929             /* unknown fields */
 930             skip_bits1(&gb);
 931             skip_bits1(&gb);
 932             skip_bits1(&gb);
 933             skip_bits1(&gb);
 934
 935             s->low_delay = get_bits1(&gb);
 936
 937             /* unknown field */
 938             skip_bits1(&gb);
 939
 940             while (get_bits1(&gb))
 941                 skip_bits(&gb, 8);
 942
 943             svq3->unknown_flag  = get_bits1(&gb);
 944             avctx->has_b_frames = !s->low_delay;
 945             if (svq3->unknown_flag) {
 946 #if CONFIG_ZLIB
 947                 unsigned watermark_width  = svq3_get_ue_golomb(&gb);
 948                 unsigned watermark_height = svq3_get_ue_golomb(&gb);
 949                 int u1                    = svq3_get_ue_golomb(&gb);
 950                 int u2                    = get_bits(&gb, 8);
 951                 int u3                    = get_bits(&gb, 2);
 952                 int u4                    = svq3_get_ue_golomb(&gb);
 953                 unsigned long buf_len     = watermark_width *
 954                                             watermark_height * 4;
 955                 int offset                = get_bits_count(&gb) + 7 >> 3;
 956                 uint8_t *buf;
 957
 958                 if ((uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
 959                     return -1;
 960
 961                 buf = av_malloc(buf_len);
 962                 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
 963                        watermark_width, watermark_height);
 964                 av_log(avctx, AV_LOG_DEBUG,
 965                        "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
 966                        u1, u2, u3, u4, offset);
 967                 if (uncompress(buf, &buf_len, extradata + 8 + offset,
 968                                size - offset) != Z_OK) {
 969                     av_log(avctx, AV_LOG_ERROR,
 970                            "could not uncompress watermark logo\n");
 971                     av_free(buf);
 972                     return -1;
 973                 }
 974                 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
 975                 svq3->watermark_key = svq3->watermark_key << 16 |
 976                                       svq3->watermark_key;
 977                 av_log(avctx, AV_LOG_DEBUG,
 978                        "watermark key %#x\n", svq3->watermark_key);
 979                 av_free(buf);
 980 #else
 981                 av_log(avctx, AV_LOG_ERROR,
 982                        "this svq3 file contains watermark which need zlib support compiled in\n");
 983                 return -1;
 984 #endif
 985             }
 986         }
 987
 988         s->width  = avctx->width;
 989         s->height = avctx->height;
 990
 991         if (ff_MPV_common_init(s) < 0)
 992             return -1;
 993
 994         h->b_stride = 4 * s->mb_width;
 995
 996         if (ff_h264_alloc_tables(h) < 0) {
 997             av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
 998             return AVERROR(ENOMEM);
 999         }
1000     }
1001
1002     return 0;
1003 }
1004
1005 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1006                              int *data_size, AVPacket *avpkt)
1007 {
1008     const uint8_t *buf = avpkt->data;
1009     SVQ3Context *svq3  = avctx->priv_data;
1010     H264Context *h     = &svq3->h;
1011     MpegEncContext *s  = &h->s;
1012     int buf_size       = avpkt->size;
1013     int m, mb_type;
1014
1015     /* special case for last picture */
1016     if (buf_size == 0) {
1017         if (s->next_picture_ptr && !s->low_delay) {
1018             *(AVFrame *) data   = s->next_picture.f;
1019             s->next_picture_ptr = NULL;
1020             *data_size          = sizeof(AVFrame);
1021         }
1022         return 0;
1023     }
1024
1025     init_get_bits(&s->gb, buf, 8 * buf_size);
1026
1027     s->mb_x = s->mb_y = h->mb_xy = 0;
1028
1029     if (svq3_decode_slice_header(avctx))
1030         return -1;
1031
1032     s->pict_type      = h->slice_type;
1033     s->picture_number = h->slice_num;
1034
1035     if (avctx->debug & FF_DEBUG_PICT_INFO)
1036         av_log(h->s.avctx, AV_LOG_DEBUG,
1037                "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1038                av_get_picture_type_char(s->pict_type),
1039                svq3->halfpel_flag, svq3->thirdpel_flag,
1040                s->adaptive_quant, s->qscale, h->slice_num);
1041
1042     /* for skipping the frame */
1043     s->current_picture.f.pict_type = s->pict_type;
1044     s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1045
1046     /* Skip B-frames if we do not have reference frames. */
1047     if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
1048         return 0;
1049     if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1050         avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1051         avctx->skip_frame >= AVDISCARD_ALL)
1052         return 0;
1053
1054     if (s->next_p_frame_damaged) {
1055         if (s->pict_type == AV_PICTURE_TYPE_B)
1056             return 0;
1057         else
1058             s->next_p_frame_damaged = 0;
1059     }
1060
1061     if (ff_h264_frame_start(h) < 0)
1062         return -1;
1063
1064     if (s->pict_type == AV_PICTURE_TYPE_B) {
1065         h->frame_num_offset = h->slice_num - h->prev_frame_num;
1066
1067         if (h->frame_num_offset < 0)
1068             h->frame_num_offset += 256;
1069         if (h->frame_num_offset == 0 ||
1070             h->frame_num_offset >= h->prev_frame_num_offset) {
1071             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1072             return -1;
1073         }
1074     } else {
1075         h->prev_frame_num        = h->frame_num;
1076         h->frame_num             = h->slice_num;
1077         h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1078
1079         if (h->prev_frame_num_offset < 0)
1080             h->prev_frame_num_offset += 256;
1081     }
1082
1083     for (m = 0; m < 2; m++) {
1084         int i;
1085         for (i = 0; i < 4; i++) {
1086             int j;
1087             for (j = -1; j < 4; j++)
1088                 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1089             if (i < 3)
1090                 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1091         }
1092     }
1093
1094     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1095         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
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 ((unsigned)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         *data_size = sizeof(AVFrame);
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 };