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 #include "svq3.h"
  61
  62 /**
  63  * @file
  64  * svq3 decoder.
  65  */
  66
  67 typedef struct {
  68     H264Context h;
  69     int halfpel_flag;
  70     int thirdpel_flag;
  71     int unknown_flag;
  72     int next_slice_index;
  73     uint32_t watermark_key;
  74 } SVQ3Context;
  75
  76 #define FULLPEL_MODE  1
  77 #define HALFPEL_MODE  2
  78 #define THIRDPEL_MODE 3
  79 #define PREDICT_MODE  4
  80
  81 /* dual scan (from some older h264 draft)
  82  * o-->o-->o   o
  83  *         |  /|
  84  * o   o   o / o
  85  * | / |   |/  |
  86  * o   o   o   o
  87  *   /
  88  * o-->o-->o-->o
  89  */
  90 static const uint8_t svq3_scan[16] = {
  91     0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
  92     2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
  93     0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
  94     0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
  95 };
  96
  97 static const uint8_t svq3_pred_0[25][2] = {
  98     { 0, 0 },
  99     { 1, 0 }, { 0, 1 },
 100     { 0, 2 }, { 1, 1 }, { 2, 0 },
 101     { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
 102     { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
 103     { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
 104     { 2, 4 }, { 3, 3 }, { 4, 2 },
 105     { 4, 3 }, { 3, 4 },
 106     { 4, 4 }
 107 };
 108
 109 static const int8_t svq3_pred_1[6][6][5] = {
 110     { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
 111       { 2,  1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
 112     { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  4,  3 }, { 0, 1,  2,  4,  3 },
 113       { 0,  2,  1,  4,  3 }, { 2, 0,  1,  3,  4 }, { 0, 4,  2,  1,  3 } },
 114     { { 2,  0, -1, -1, -1 }, { 2, 1,  0,  4,  3 }, { 1, 2,  4,  0,  3 },
 115       { 2,  1,  0,  4,  3 }, { 2, 1,  4,  3,  0 }, { 1, 2,  4,  0,  3 } },
 116     { { 2,  0, -1, -1, -1 }, { 2, 0,  1,  4,  3 }, { 1, 2,  0,  4,  3 },
 117       { 2,  1,  0,  4,  3 }, { 2, 1,  3,  4,  0 }, { 2, 4,  1,  0,  3 } },
 118     { { 0,  2, -1, -1, -1 }, { 0, 2,  1,  3,  4 }, { 1, 2,  3,  0,  4 },
 119       { 2,  0,  1,  3,  4 }, { 2, 1,  3,  0,  4 }, { 2, 0,  4,  3,  1 } },
 120     { { 0,  2, -1, -1, -1 }, { 0, 2,  4,  1,  3 }, { 1, 4,  2,  0,  3 },
 121       { 4,  2,  0,  1,  3 }, { 2, 0,  1,  4,  3 }, { 4, 2,  1,  0,  3 } },
 122 };
 123
 124 static const struct {
 125     uint8_t run;
 126     uint8_t level;
 127 } svq3_dct_tables[2][16] = {
 128     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
 129       { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
 130     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
 131       { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
 132 };
 133
 134 static const uint32_t svq3_dequant_coeff[32] = {
 135      3881,  4351,  4890,  5481,   6154,   6914,   7761,   8718,
 136      9781, 10987, 12339, 13828,  15523,  17435,  19561,  21873,
 137     24552, 27656, 30847, 34870,  38807,  43747,  49103,  54683,
 138     61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
 139 };
 140
 141 void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
 142 {
 143     const int qmul = svq3_dequant_coeff[qp];
 144 #define stride 16
 145     int i;
 146     int temp[16];
 147     static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
 148
 149     for (i = 0; i < 4; i++) {
 150         const int z0 = 13 * (input[4 * i + 0] +      input[4 * i + 2]);
 151         const int z1 = 13 * (input[4 * i + 0] -      input[4 * i + 2]);
 152         const int z2 =  7 *  input[4 * i + 1] - 17 * input[4 * i + 3];
 153         const int z3 = 17 *  input[4 * i + 1] +  7 * input[4 * i + 3];
 154
 155         temp[4 * i + 0] = z0 + z3;
 156         temp[4 * i + 1] = z1 + z2;
 157         temp[4 * i + 2] = z1 - z2;
 158         temp[4 * i + 3] = z0 - z3;
 159     }
 160
 161     for (i = 0; i < 4; i++) {
 162         const int offset = x_offset[i];
 163         const int z0     = 13 * (temp[4 * 0 + i] +      temp[4 * 2 + i]);
 164         const int z1     = 13 * (temp[4 * 0 + i] -      temp[4 * 2 + i]);
 165         const int z2     =  7 *  temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
 166         const int z3     = 17 *  temp[4 * 1 + i] +  7 * temp[4 * 3 + i];
 167
 168         output[stride *  0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
 169         output[stride *  2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
 170         output[stride *  8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
 171         output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
 172     }
 173 }
 174 #undef stride
 175
 176 void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
 177                         int stride, int qp, int dc)
 178 {
 179     const int qmul = svq3_dequant_coeff[qp];
 180     int i;
 181
 182     if (dc) {
 183         dc       = 13 * 13 * (dc == 1 ? 1538 * block[0]
 184                                       : qmul * (block[0] >> 3) / 2);
 185         block[0] = 0;
 186     }
 187
 188     for (i = 0; i < 4; i++) {
 189         const int z0 = 13 * (block[0 + 4 * i] +      block[2 + 4 * i]);
 190         const int z1 = 13 * (block[0 + 4 * i] -      block[2 + 4 * i]);
 191         const int z2 =  7 *  block[1 + 4 * i] - 17 * block[3 + 4 * i];
 192         const int z3 = 17 *  block[1 + 4 * i] +  7 * block[3 + 4 * i];
 193
 194         block[0 + 4 * i] = z0 + z3;
 195         block[1 + 4 * i] = z1 + z2;
 196         block[2 + 4 * i] = z1 - z2;
 197         block[3 + 4 * i] = z0 - z3;
 198     }
 199
 200     for (i = 0; i < 4; i++) {
 201         const int z0 = 13 * (block[i + 4 * 0] +      block[i + 4 * 2]);
 202         const int z1 = 13 * (block[i + 4 * 0] -      block[i + 4 * 2]);
 203         const int z2 =  7 *  block[i + 4 * 1] - 17 * block[i + 4 * 3];
 204         const int z3 = 17 *  block[i + 4 * 1] +  7 * block[i + 4 * 3];
 205         const int rr = (dc + 0x80000);
 206
 207         dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
 208         dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
 209         dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
 210         dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
 211     }
 212 }
 213
 214 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
 215                                     int index, const int type)
 216 {
 217     static const uint8_t *const scan_patterns[4] =
 218     { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
 219
 220     int run, level, limit;
 221     unsigned vlc;
 222     const int intra           = 3 * type >> 2;
 223     const uint8_t *const scan = scan_patterns[type];
 224
 225     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
 226         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
 227             int sign = (vlc & 1) ? 0 : -1;
 228             vlc      = vlc + 1 >> 1;
 229
 230             if (type == 3) {
 231                 if (vlc < 3) {
 232                     run   = 0;
 233                     level = vlc;
 234                 } else if (vlc < 4) {
 235                     run   = 1;
 236                     level = 1;
 237                 } else {
 238                     run   = vlc & 0x3;
 239                     level = (vlc + 9 >> 2) - run;
 240                 }
 241             } else {
 242                 if (vlc < 16) {
 243                     run   = svq3_dct_tables[intra][vlc].run;
 244                     level = svq3_dct_tables[intra][vlc].level;
 245                 } else if (intra) {
 246                     run   = vlc & 0x7;
 247                     level = (vlc >> 3) +
 248                             ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
 249                 } else {
 250                     run   = vlc & 0xF;
 251                     level = (vlc >> 4) +
 252                             ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
 253                 }
 254             }
 255
 256             if ((index += run) >= limit)
 257                 return -1;
 258
 259             block[scan[index]] = (level ^ sign) - sign;
 260         }
 261
 262         if (type != 2) {
 263             break;
 264         }
 265     }
 266
 267     return 0;
 268 }
 269
 270 static inline void svq3_mc_dir_part(MpegEncContext *s,
 271                                     int x, int y, int width, int height,
 272                                     int mx, int my, int dxy,
 273                                     int thirdpel, int dir, int avg)
 274 {
 275     const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
 276     uint8_t *src, *dest;
 277     int i, emu = 0;
 278     int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
 279
 280     mx += x;
 281     my += y;
 282
 283     if (mx < 0 || mx >= s->h_edge_pos - width  - 1 ||
 284         my < 0 || my >= s->v_edge_pos - height - 1) {
 285         if ((s->flags & CODEC_FLAG_EMU_EDGE))
 286             emu = 1;
 287
 288         mx = av_clip(mx, -16, s->h_edge_pos - width  + 15);
 289         my = av_clip(my, -16, s->v_edge_pos - height + 15);
 290     }
 291
 292     /* form component predictions */
 293     dest = s->current_picture.f.data[0] + x + y * s->linesize;
 294     src  = pic->f.data[0] + mx + my * s->linesize;
 295
 296     if (emu) {
 297         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize,
 298                                  width + 1, height + 1,
 299                                  mx, my, s->h_edge_pos, s->v_edge_pos);
 300         src = s->edge_emu_buffer;
 301     }
 302     if (thirdpel)
 303         (avg ? s->dsp.avg_tpel_pixels_tab
 304              : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize,
 305                                                 width, height);
 306     else
 307         (avg ? s->dsp.avg_pixels_tab
 308              : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize,
 309                                                       height);
 310
 311     if (!(s->flags & CODEC_FLAG_GRAY)) {
 312         mx     = mx + (mx < (int) x) >> 1;
 313         my     = my + (my < (int) y) >> 1;
 314         width  = width  >> 1;
 315         height = height >> 1;
 316         blocksize++;
 317
 318         for (i = 1; i < 3; i++) {
 319             dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
 320             src  = pic->f.data[i] + mx + my * s->uvlinesize;
 321
 322             if (emu) {
 323                 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize,
 324                                          width + 1, height + 1,
 325                                          mx, my, (s->h_edge_pos >> 1),
 326                                          s->v_edge_pos >> 1);
 327                 src = s->edge_emu_buffer;
 328             }
 329             if (thirdpel)
 330                 (avg ? s->dsp.avg_tpel_pixels_tab
 331                      : s->dsp.put_tpel_pixels_tab)[dxy](dest, src,
 332                                                         s->uvlinesize,
 333                                                         width, height);
 334             else
 335                 (avg ? s->dsp.avg_pixels_tab
 336                      : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
 337                                                               s->uvlinesize,
 338                                                               height);
 339         }
 340     }
 341 }
 342
 343 static inline int svq3_mc_dir(H264Context *h, int size, int mode,
 344                               int dir, int avg)
 345 {
 346     int i, j, k, mx, my, dx, dy, x, y;
 347     MpegEncContext *const s = (MpegEncContext *)h;
 348     const int part_width    = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
 349     const int part_height   = 16 >> ((unsigned)(size + 1) / 3);
 350     const int extra_width   = (mode == PREDICT_MODE) ? -16 * 6 : 0;
 351     const int h_edge_pos    = 6 * (s->h_edge_pos - part_width)  - extra_width;
 352     const int v_edge_pos    = 6 * (s->v_edge_pos - part_height) - extra_width;
 353
 354     for (i = 0; i < 16; i += part_height)
 355         for (j = 0; j < 16; j += part_width) {
 356             const int b_xy = (4 * s->mb_x + (j >> 2)) +
 357                              (4 * s->mb_y + (i >> 2)) * h->b_stride;
 358             int dxy;
 359             x = 16 * s->mb_x + j;
 360             y = 16 * s->mb_y + i;
 361             k = (j >> 2 & 1) + (i >> 1 & 2) +
 362                 (j >> 1 & 4) + (i      & 8);
 363
 364             if (mode != PREDICT_MODE) {
 365                 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
 366             } else {
 367                 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
 368                 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
 369
 370                 if (dir == 0) {
 371                     mx = mx * h->frame_num_offset /
 372                          h->prev_frame_num_offset + 1 >> 1;
 373                     my = my * h->frame_num_offset /
 374                          h->prev_frame_num_offset + 1 >> 1;
 375                 } else {
 376                     mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
 377                          h->prev_frame_num_offset + 1 >> 1;
 378                     my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
 379                          h->prev_frame_num_offset + 1 >> 1;
 380                 }
 381             }
 382
 383             /* clip motion vector prediction to frame border */
 384             mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
 385             my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
 386
 387             /* get (optional) motion vector differential */
 388             if (mode == PREDICT_MODE) {
 389                 dx = dy = 0;
 390             } else {
 391                 dy = svq3_get_se_golomb(&s->gb);
 392                 dx = svq3_get_se_golomb(&s->gb);
 393
 394                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
 395                     av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
 396                     return -1;
 397                 }
 398             }
 399
 400             /* compute motion vector */
 401             if (mode == THIRDPEL_MODE) {
 402                 int fx, fy;
 403                 mx  = (mx + 1 >> 1) + dx;
 404                 my  = (my + 1 >> 1) + dy;
 405                 fx  = (unsigned)(mx + 0x3000) / 3 - 0x1000;
 406                 fy  = (unsigned)(my + 0x3000) / 3 - 0x1000;
 407                 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
 408
 409                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 410                                  fx, fy, dxy, 1, dir, avg);
 411                 mx += mx;
 412                 my += my;
 413             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
 414                 mx  = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
 415                 my  = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
 416                 dxy = (mx & 1) + 2 * (my & 1);
 417
 418                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 419                                  mx >> 1, my >> 1, dxy, 0, dir, avg);
 420                 mx *= 3;
 421                 my *= 3;
 422             } else {
 423                 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
 424                 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
 425
 426                 svq3_mc_dir_part(s, x, y, part_width, part_height,
 427                                  mx, my, 0, 0, dir, avg);
 428                 mx *= 6;
 429                 my *= 6;
 430             }
 431
 432             /* update mv_cache */
 433             if (mode != PREDICT_MODE) {
 434                 int32_t mv = pack16to32(mx, my);
 435
 436                 if (part_height == 8 && i < 8) {
 437                     AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
 438
 439                     if (part_width == 8 && j < 8)
 440                         AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
 441                 }
 442                 if (part_width == 8 && j < 8)
 443                     AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
 444                 if (part_width == 4 || part_height == 4)
 445                     AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
 446             }
 447
 448             /* write back motion vectors */
 449             fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
 450                            part_width >> 2, part_height >> 2, h->b_stride,
 451                            pack16to32(mx, my), 4);
 452         }
 453
 454     return 0;
 455 }
 456
 457 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
 458 {
 459     H264Context *h = &svq3->h;
 460     int i, j, k, m, dir, mode;
 461     int cbp = 0;
 462     uint32_t vlc;
 463     int8_t *top, *left;
 464     MpegEncContext *const s = (MpegEncContext *)h;
 465     const int mb_xy         = h->mb_xy;
 466     const int b_xy          = 4 * s->mb_x + 4 * s->mb_y * h->b_stride;
 467
 468     h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 469     h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 470     h->topright_samples_available = 0xFFFF;
 471
 472     if (mb_type == 0) {           /* SKIP */
 473         if (s->pict_type == AV_PICTURE_TYPE_P ||
 474             s->next_picture.f.mb_type[mb_xy] == -1) {
 475             svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 476                              0, 0, 0, 0, 0, 0);
 477
 478             if (s->pict_type == AV_PICTURE_TYPE_B)
 479                 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
 480                                  0, 0, 0, 0, 1, 1);
 481
 482             mb_type = MB_TYPE_SKIP;
 483         } else {
 484             mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
 485             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
 486                 return -1;
 487             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
 488                 return -1;
 489
 490             mb_type = MB_TYPE_16x16;
 491         }
 492     } else if (mb_type < 8) {     /* INTER */
 493         if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1(&s->gb))
 494             mode = THIRDPEL_MODE;
 495         else if (svq3->halfpel_flag &&
 496                  svq3->thirdpel_flag == !get_bits1(&s->gb))
 497             mode = HALFPEL_MODE;
 498         else
 499             mode = FULLPEL_MODE;
 500
 501         /* fill caches */
 502         /* note ref_cache should contain here:
 503          *  ????????
 504          *  ???11111
 505          *  N??11111
 506          *  N??11111
 507          *  N??11111
 508          */
 509
 510         for (m = 0; m < 2; m++) {
 511             if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
 512                 for (i = 0; i < 4; i++)
 513                     AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
 514                               s->current_picture.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
 515             } else {
 516                 for (i = 0; i < 4; i++)
 517                     AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
 518             }
 519             if (s->mb_y > 0) {
 520                 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
 521                        s->current_picture.f.motion_val[m][b_xy - h->b_stride],
 522                        4 * 2 * sizeof(int16_t));
 523                 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
 524                        (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
 525
 526                 if (s->mb_x < s->mb_width - 1) {
 527                     AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
 528                               s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
 529                     h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
 530                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
 531                          h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
 532                 } else
 533                     h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
 534                 if (s->mb_x > 0) {
 535                     AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
 536                               s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
 537                     h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
 538                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
 539                 } else
 540                     h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
 541             } else
 542                 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
 543                        PART_NOT_AVAILABLE, 8);
 544
 545             if (s->pict_type != AV_PICTURE_TYPE_B)
 546                 break;
 547         }
 548
 549         /* decode motion vector(s) and form prediction(s) */
 550         if (s->pict_type == AV_PICTURE_TYPE_P) {
 551             if (svq3_mc_dir(h, mb_type - 1, mode, 0, 0) < 0)
 552                 return -1;
 553         } else {        /* AV_PICTURE_TYPE_B */
 554             if (mb_type != 2)
 555                 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
 556                     return -1;
 557             else
 558                 for (i = 0; i < 4; i++)
 559                     memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
 560                            0, 4 * 2 * sizeof(int16_t));
 561             if (mb_type != 1)
 562                 if (svq3_mc_dir(h, 0, mode, 1, mb_type == 3) < 0)
 563                     return -1;
 564             else
 565                 for (i = 0; i < 4; i++)
 566                     memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
 567                            0, 4 * 2 * sizeof(int16_t));
 568         }
 569
 570         mb_type = MB_TYPE_16x16;
 571     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
 572         memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
 573
 574         if (mb_type == 8) {
 575             if (s->mb_x > 0) {
 576                 for (i = 0; i < 4; i++)
 577                     h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
 578                 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
 579                     h->left_samples_available = 0x5F5F;
 580             }
 581             if (s->mb_y > 0) {
 582                 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 0];
 583                 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 1];
 584                 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 2];
 585                 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 3];
 586
 587                 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
 588                     h->top_samples_available = 0x33FF;
 589             }
 590
 591             /* decode prediction codes for luma blocks */
 592             for (i = 0; i < 16; i += 2) {
 593                 vlc = svq3_get_ue_golomb(&s->gb);
 594
 595                 if (vlc >= 25) {
 596                     av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
 597                     return -1;
 598                 }
 599
 600                 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
 601                 top  = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
 602
 603                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
 604                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
 605
 606                 if (left[1] == -1 || left[2] == -1) {
 607                     av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
 608                     return -1;
 609                 }
 610             }
 611         } else {    /* mb_type == 33, DC_128_PRED block type */
 612             for (i = 0; i < 4; i++)
 613                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
 614         }
 615
 616         write_back_intra_pred_mode(h);
 617
 618         if (mb_type == 8) {
 619             ff_h264_check_intra4x4_pred_mode(h);
 620
 621             h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
 622             h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
 623         } else {
 624             for (i = 0; i < 4; i++)
 625                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
 626
 627             h->top_samples_available  = 0x33FF;
 628             h->left_samples_available = 0x5F5F;
 629         }
 630
 631         mb_type = MB_TYPE_INTRA4x4;
 632     } else {                      /* INTRA16x16 */
 633         dir = i_mb_type_info[mb_type - 8].pred_mode;
 634         dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
 635
 636         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
 637             av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
 638             return -1;
 639         }
 640
 641         cbp     = i_mb_type_info[mb_type - 8].cbp;
 642         mb_type = MB_TYPE_INTRA16x16;
 643     }
 644
 645     if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
 646         for (i = 0; i < 4; i++)
 647             memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
 648                    0, 4 * 2 * sizeof(int16_t));
 649         if (s->pict_type == AV_PICTURE_TYPE_B) {
 650             for (i = 0; i < 4; i++)
 651                 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
 652                        0, 4 * 2 * sizeof(int16_t));
 653         }
 654     }
 655     if (!IS_INTRA4x4(mb_type)) {
 656         memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
 657     }
 658     if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
 659         memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
 660         s->dsp.clear_blocks(h->mb +   0);
 661         s->dsp.clear_blocks(h->mb + 384);
 662     }
 663
 664     if (!IS_INTRA16x16(mb_type) &&
 665         (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
 666         if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48) {
 667             av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
 668             return -1;
 669         }
 670
 671         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
 672                                 : golomb_to_inter_cbp[vlc];
 673     }
 674     if (IS_INTRA16x16(mb_type) ||
 675         (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
 676         s->qscale += svq3_get_se_golomb(&s->gb);
 677
 678         if (s->qscale > 31u) {
 679             av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
 680             return -1;
 681         }
 682     }
 683     if (IS_INTRA16x16(mb_type)) {
 684         AV_ZERO128(h->mb_luma_dc[0] + 0);
 685         AV_ZERO128(h->mb_luma_dc[0] + 8);
 686         if (svq3_decode_block(&s->gb, h->mb_luma_dc[0], 0, 1)) {
 687             av_log(h->s.avctx, AV_LOG_ERROR,
 688                    "error while decoding intra luma dc\n");
 689             return -1;
 690         }
 691     }
 692
 693     if (cbp) {
 694         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
 695         const int type  = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
 696
 697         for (i = 0; i < 4; i++)
 698             if ((cbp & (1 << i))) {
 699                 for (j = 0; j < 4; j++) {
 700                     k = index ? (1 * (j & 1) + 2 * (i & 1) +
 701                                  2 * (j & 2) + 4 * (i & 2))
 702                               : (4 * i + j);
 703                     h->non_zero_count_cache[scan8[k]] = 1;
 704
 705                     if (svq3_decode_block(&s->gb, &h->mb[16 * k], index, type)) {
 706                         av_log(h->s.avctx, AV_LOG_ERROR,
 707                                "error while decoding block\n");
 708                         return -1;
 709                     }
 710                 }
 711             }
 712
 713         if ((cbp & 0x30)) {
 714             for (i = 1; i < 3; ++i)
 715                 if (svq3_decode_block(&s->gb, &h->mb[16 * 16 * i], 0, 3)) {
 716                     av_log(h->s.avctx, AV_LOG_ERROR,
 717                            "error while decoding chroma dc block\n");
 718                     return -1;
 719                 }
 720
 721             if ((cbp & 0x20)) {
 722                 for (i = 1; i < 3; i++) {
 723                     for (j = 0; j < 4; j++) {
 724                         k                                 = 16 * i + j;
 725                         h->non_zero_count_cache[scan8[k]] = 1;
 726
 727                         if (svq3_decode_block(&s->gb, &h->mb[16 * k], 1, 1)) {
 728                             av_log(h->s.avctx, AV_LOG_ERROR,
 729                                    "error while decoding chroma ac block\n");
 730                             return -1;
 731                         }
 732                     }
 733                 }
 734             }
 735         }
 736     }
 737
 738     h->cbp                              = cbp;
 739     s->current_picture.f.mb_type[mb_xy] = mb_type;
 740
 741     if (IS_INTRA(mb_type))
 742         h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
 743
 744     return 0;
 745 }
 746
 747 static int svq3_decode_slice_header(AVCodecContext *avctx)
 748 {
 749     SVQ3Context *svq3 = avctx->priv_data;
 750     H264Context *h    = &svq3->h;
 751     MpegEncContext *s = &h->s;
 752     const int mb_xy   = h->mb_xy;
 753     int i, header;
 754     unsigned slice_id;
 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 ((slice_id = svq3_get_ue_golomb(&s->gb)) >= 3) {
 790         av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", slice_id);
 791         return -1;
 792     }
 793
 794     h->slice_type = golomb_to_pict_type[slice_id];
 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 *got_frame, 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;
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             *got_frame          = 1;
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             unsigned mb_type;
1097             h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1098
1099             if ((get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1100                 ((get_bits_count(&s->gb) & 7) == 0 ||
1101                  show_bits(&s->gb, -get_bits_count(&s->gb) & 7) == 0)) {
1102                 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1103                 s->gb.size_in_bits = 8 * buf_size;
1104
1105                 if (svq3_decode_slice_header(avctx))
1106                     return -1;
1107
1108                 /* TODO: support s->mb_skip_run */
1109             }
1110
1111             mb_type = svq3_get_ue_golomb(&s->gb);
1112
1113             if (s->pict_type == AV_PICTURE_TYPE_I)
1114                 mb_type += 8;
1115             else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1116                 mb_type += 4;
1117             if (mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1118                 av_log(h->s.avctx, AV_LOG_ERROR,
1119                        "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1120                 return -1;
1121             }
1122
1123             if (mb_type != 0)
1124                 ff_h264_hl_decode_mb(h);
1125
1126             if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1127                 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1128                     (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1129         }
1130
1131         ff_draw_horiz_band(s, 16 * s->mb_y, 16);
1132     }
1133
1134     ff_MPV_frame_end(s);
1135
1136     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1137         *(AVFrame *)data = s->current_picture.f;
1138     else
1139         *(AVFrame *)data = s->last_picture.f;
1140
1141     /* Do not output the last pic after seeking. */
1142     if (s->last_picture_ptr || s->low_delay)
1143         *got_frame = 1;
1144
1145     return buf_size;
1146 }
1147
1148 static int svq3_decode_end(AVCodecContext *avctx)
1149 {
1150     SVQ3Context *svq3 = avctx->priv_data;
1151     H264Context *h    = &svq3->h;
1152     MpegEncContext *s = &h->s;
1153
1154     ff_h264_free_context(h);
1155
1156     ff_MPV_common_end(s);
1157
1158     return 0;
1159 }
1160
1161 AVCodec ff_svq3_decoder = {
1162     .name           = "svq3",
1163     .type           = AVMEDIA_TYPE_VIDEO,
1164     .id             = AV_CODEC_ID_SVQ3,
1165     .priv_data_size = sizeof(SVQ3Context),
1166     .init           = svq3_decode_init,
1167     .close          = svq3_decode_end,
1168     .decode         = svq3_decode_frame,
1169     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND |
1170                       CODEC_CAP_DR1             |
1171                       CODEC_CAP_DELAY,
1172     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1173     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1174                                                      AV_PIX_FMT_NONE},
1175 };