• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/svq3.c

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2003 The FFmpeg Project
00003  *
00004  * This file is part of FFmpeg.
00005  *
00006  * FFmpeg is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * FFmpeg is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with FFmpeg; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019  */
00020 
00021 /*
00022  * How to use this decoder:
00023  * SVQ3 data is transported within Apple Quicktime files. Quicktime files
00024  * have stsd atoms to describe media trak properties. A stsd atom for a
00025  * video trak contains 1 or more ImageDescription atoms. These atoms begin
00026  * with the 4-byte length of the atom followed by the codec fourcc. Some
00027  * decoders need information in this atom to operate correctly. Such
00028  * is the case with SVQ3. In order to get the best use out of this decoder,
00029  * the calling app must make the SVQ3 ImageDescription atom available
00030  * via the AVCodecContext's extradata[_size] field:
00031  *
00032  * AVCodecContext.extradata = pointer to ImageDescription, first characters
00033  * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
00034  * AVCodecContext.extradata_size = size of ImageDescription atom memory
00035  * buffer (which will be the same as the ImageDescription atom size field
00036  * from the QT file, minus 4 bytes since the length is missing)
00037  *
00038  * You will know you have these parameters passed correctly when the decoder
00039  * correctly decodes this file:
00040  *  http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
00041  */
00042 #include "internal.h"
00043 #include "dsputil.h"
00044 #include "avcodec.h"
00045 #include "mpegvideo.h"
00046 #include "h264.h"
00047 
00048 #include "h264data.h" //FIXME FIXME FIXME
00049 
00050 #include "h264_mvpred.h"
00051 #include "golomb.h"
00052 #include "rectangle.h"
00053 #include "vdpau_internal.h"
00054 
00055 #if CONFIG_ZLIB
00056 #include <zlib.h>
00057 #endif
00058 
00059 #include "svq1.h"
00060 
00066 #define FULLPEL_MODE  1
00067 #define HALFPEL_MODE  2
00068 #define THIRDPEL_MODE 3
00069 #define PREDICT_MODE  4
00070 
00071 /* dual scan (from some older h264 draft)
00072  o-->o-->o   o
00073          |  /|
00074  o   o   o / o
00075  | / |   |/  |
00076  o   o   o   o
00077    /
00078  o-->o-->o-->o
00079 */
00080 static const uint8_t svq3_scan[16] = {
00081     0+0*4, 1+0*4, 2+0*4, 2+1*4,
00082     2+2*4, 3+0*4, 3+1*4, 3+2*4,
00083     0+1*4, 0+2*4, 1+1*4, 1+2*4,
00084     0+3*4, 1+3*4, 2+3*4, 3+3*4,
00085 };
00086 
00087 static const uint8_t svq3_pred_0[25][2] = {
00088     { 0, 0 },
00089     { 1, 0 }, { 0, 1 },
00090     { 0, 2 }, { 1, 1 }, { 2, 0 },
00091     { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
00092     { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
00093     { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
00094     { 2, 4 }, { 3, 3 }, { 4, 2 },
00095     { 4, 3 }, { 3, 4 },
00096     { 4, 4 }
00097 };
00098 
00099 static const int8_t svq3_pred_1[6][6][5] = {
00100     { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
00101       { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
00102     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
00103       { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
00104     { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
00105       { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
00106     { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
00107       { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
00108     { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
00109       { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
00110     { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
00111       { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
00112 };
00113 
00114 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
00115     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
00116       { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
00117     { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
00118       { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
00119 };
00120 
00121 static const uint32_t svq3_dequant_coeff[32] = {
00122      3881,  4351,  4890,  5481,  6154,  6914,  7761,  8718,
00123      9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
00124     24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
00125     61694, 68745, 77615, 89113,100253,109366,126635,141533
00126 };
00127 
00128 
00129 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp)
00130 {
00131     const int qmul = svq3_dequant_coeff[qp];
00132 #define stride 16
00133     int i;
00134     int temp[16];
00135     static const int x_offset[4] = {0, 1*stride, 4* stride,  5*stride};
00136     static const int y_offset[4] = {0, 2*stride, 8* stride, 10*stride};
00137 
00138     for (i = 0; i < 4; i++){
00139         const int offset = y_offset[i];
00140         const int z0 = 13*(block[offset+stride*0] +    block[offset+stride*4]);
00141         const int z1 = 13*(block[offset+stride*0] -    block[offset+stride*4]);
00142         const int z2 =  7* block[offset+stride*1] - 17*block[offset+stride*5];
00143         const int z3 = 17* block[offset+stride*1] +  7*block[offset+stride*5];
00144 
00145         temp[4*i+0] = z0+z3;
00146         temp[4*i+1] = z1+z2;
00147         temp[4*i+2] = z1-z2;
00148         temp[4*i+3] = z0-z3;
00149     }
00150 
00151     for (i = 0; i < 4; i++){
00152         const int offset = x_offset[i];
00153         const int z0 = 13*(temp[4*0+i] +    temp[4*2+i]);
00154         const int z1 = 13*(temp[4*0+i] -    temp[4*2+i]);
00155         const int z2 =  7* temp[4*1+i] - 17*temp[4*3+i];
00156         const int z3 = 17* temp[4*1+i] +  7*temp[4*3+i];
00157 
00158         block[stride*0 +offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
00159         block[stride*2 +offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
00160         block[stride*8 +offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
00161         block[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
00162     }
00163 }
00164 #undef stride
00165 
00166 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
00167                             int dc)
00168 {
00169     const int qmul = svq3_dequant_coeff[qp];
00170     int i;
00171     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
00172 
00173     if (dc) {
00174         dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
00175         block[0] = 0;
00176     }
00177 
00178     for (i = 0; i < 4; i++) {
00179         const int z0 = 13*(block[0 + 4*i] +    block[2 + 4*i]);
00180         const int z1 = 13*(block[0 + 4*i] -    block[2 + 4*i]);
00181         const int z2 =  7* block[1 + 4*i] - 17*block[3 + 4*i];
00182         const int z3 = 17* block[1 + 4*i] +  7*block[3 + 4*i];
00183 
00184         block[0 + 4*i] = z0 + z3;
00185         block[1 + 4*i] = z1 + z2;
00186         block[2 + 4*i] = z1 - z2;
00187         block[3 + 4*i] = z0 - z3;
00188     }
00189 
00190     for (i = 0; i < 4; i++) {
00191         const int z0 = 13*(block[i + 4*0] +    block[i + 4*2]);
00192         const int z1 = 13*(block[i + 4*0] -    block[i + 4*2]);
00193         const int z2 =  7* block[i + 4*1] - 17*block[i + 4*3];
00194         const int z3 = 17* block[i + 4*1] +  7*block[i + 4*3];
00195         const int rr = (dc + 0x80000);
00196 
00197         dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
00198         dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
00199         dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
00200         dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
00201     }
00202 }
00203 
00204 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
00205                                     int index, const int type)
00206 {
00207     static const uint8_t *const scan_patterns[4] =
00208     { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
00209 
00210     int run, level, sign, vlc, limit;
00211     const int intra = (3 * type) >> 2;
00212     const uint8_t *const scan = scan_patterns[type];
00213 
00214     for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
00215         for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
00216 
00217           if (vlc == INVALID_VLC)
00218               return -1;
00219 
00220           sign = (vlc & 0x1) - 1;
00221           vlc  = (vlc + 1) >> 1;
00222 
00223           if (type == 3) {
00224               if (vlc < 3) {
00225                   run   = 0;
00226                   level = vlc;
00227               } else if (vlc < 4) {
00228                   run   = 1;
00229                   level = 1;
00230               } else {
00231                   run   = (vlc & 0x3);
00232                   level = ((vlc + 9) >> 2) - run;
00233               }
00234           } else {
00235               if (vlc < 16) {
00236                   run   = svq3_dct_tables[intra][vlc].run;
00237                   level = svq3_dct_tables[intra][vlc].level;
00238               } else if (intra) {
00239                   run   = (vlc & 0x7);
00240                   level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
00241               } else {
00242                   run   = (vlc & 0xF);
00243                   level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
00244               }
00245           }
00246 
00247           if ((index += run) >= limit)
00248               return -1;
00249 
00250           block[scan[index]] = (level ^ sign) - sign;
00251         }
00252 
00253         if (type != 2) {
00254             break;
00255         }
00256     }
00257 
00258     return 0;
00259 }
00260 
00261 static inline void svq3_mc_dir_part(MpegEncContext *s,
00262                                     int x, int y, int width, int height,
00263                                     int mx, int my, int dxy,
00264                                     int thirdpel, int dir, int avg)
00265 {
00266     const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
00267     uint8_t *src, *dest;
00268     int i, emu = 0;
00269     int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
00270 
00271     mx += x;
00272     my += y;
00273 
00274     if (mx < 0 || mx >= (s->h_edge_pos - width  - 1) ||
00275         my < 0 || my >= (s->v_edge_pos - height - 1)) {
00276 
00277         if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
00278             emu = 1;
00279         }
00280 
00281         mx = av_clip (mx, -16, (s->h_edge_pos - width  + 15));
00282         my = av_clip (my, -16, (s->v_edge_pos - height + 15));
00283     }
00284 
00285     /* form component predictions */
00286     dest = s->current_picture.data[0] + x + y*s->linesize;
00287     src  = pic->data[0] + mx + my*s->linesize;
00288 
00289     if (emu) {
00290         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
00291                             mx, my, s->h_edge_pos, s->v_edge_pos);
00292         src = s->edge_emu_buffer;
00293     }
00294     if (thirdpel)
00295         (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
00296     else
00297         (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
00298 
00299     if (!(s->flags & CODEC_FLAG_GRAY)) {
00300         mx     = (mx + (mx < (int) x)) >> 1;
00301         my     = (my + (my < (int) y)) >> 1;
00302         width  = (width  >> 1);
00303         height = (height >> 1);
00304         blocksize++;
00305 
00306         for (i = 1; i < 3; i++) {
00307             dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
00308             src  = pic->data[i] + mx + my*s->uvlinesize;
00309 
00310             if (emu) {
00311                 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
00312                                     mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
00313                 src = s->edge_emu_buffer;
00314             }
00315             if (thirdpel)
00316                 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
00317             else
00318                 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
00319         }
00320     }
00321 }
00322 
00323 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
00324                               int avg)
00325 {
00326     int i, j, k, mx, my, dx, dy, x, y;
00327     MpegEncContext *const s = (MpegEncContext *) h;
00328     const int part_width  = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
00329     const int part_height = 16 >> ((unsigned) (size + 1) / 3);
00330     const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
00331     const int h_edge_pos  = 6*(s->h_edge_pos - part_width ) - extra_width;
00332     const int v_edge_pos  = 6*(s->v_edge_pos - part_height) - extra_width;
00333 
00334     for (i = 0; i < 16; i += part_height) {
00335         for (j = 0; j < 16; j += part_width) {
00336             const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
00337             int dxy;
00338             x = 16*s->mb_x + j;
00339             y = 16*s->mb_y + i;
00340             k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
00341 
00342             if (mode != PREDICT_MODE) {
00343                 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
00344             } else {
00345                 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
00346                 my = s->next_picture.motion_val[0][b_xy][1]<<1;
00347 
00348                 if (dir == 0) {
00349                     mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
00350                     my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
00351                 } else {
00352                     mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
00353                     my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
00354                 }
00355             }
00356 
00357             /* clip motion vector prediction to frame border */
00358             mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
00359             my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
00360 
00361             /* get (optional) motion vector differential */
00362             if (mode == PREDICT_MODE) {
00363                 dx = dy = 0;
00364             } else {
00365                 dy = svq3_get_se_golomb(&s->gb);
00366                 dx = svq3_get_se_golomb(&s->gb);
00367 
00368                 if (dx == INVALID_VLC || dy == INVALID_VLC) {
00369                     av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
00370                     return -1;
00371                 }
00372             }
00373 
00374             /* compute motion vector */
00375             if (mode == THIRDPEL_MODE) {
00376                 int fx, fy;
00377                 mx  = ((mx + 1)>>1) + dx;
00378                 my  = ((my + 1)>>1) + dy;
00379                 fx  = ((unsigned)(mx + 0x3000))/3 - 0x1000;
00380                 fy  = ((unsigned)(my + 0x3000))/3 - 0x1000;
00381                 dxy = (mx - 3*fx) + 4*(my - 3*fy);
00382 
00383                 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
00384                 mx += mx;
00385                 my += my;
00386             } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
00387                 mx  = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
00388                 my  = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
00389                 dxy = (mx&1) + 2*(my&1);
00390 
00391                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
00392                 mx *= 3;
00393                 my *= 3;
00394             } else {
00395                 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
00396                 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
00397 
00398                 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
00399                 mx *= 6;
00400                 my *= 6;
00401             }
00402 
00403             /* update mv_cache */
00404             if (mode != PREDICT_MODE) {
00405                 int32_t mv = pack16to32(mx,my);
00406 
00407                 if (part_height == 8 && i < 8) {
00408                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
00409 
00410                     if (part_width == 8 && j < 8) {
00411                         *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
00412                     }
00413                 }
00414                 if (part_width == 8 && j < 8) {
00415                     *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
00416                 }
00417                 if (part_width == 4 || part_height == 4) {
00418                     *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
00419                 }
00420             }
00421 
00422             /* write back motion vectors */
00423             fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
00424         }
00425     }
00426 
00427     return 0;
00428 }
00429 
00430 static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
00431 {
00432     int i, j, k, m, dir, mode;
00433     int cbp = 0;
00434     uint32_t vlc;
00435     int8_t *top, *left;
00436     MpegEncContext *const s = (MpegEncContext *) h;
00437     const int mb_xy = h->mb_xy;
00438     const int b_xy  = 4*s->mb_x + 4*s->mb_y*h->b_stride;
00439 
00440     h->top_samples_available      = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
00441     h->left_samples_available     = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
00442     h->topright_samples_available = 0xFFFF;
00443 
00444     if (mb_type == 0) {           /* SKIP */
00445         if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
00446             svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
00447 
00448             if (s->pict_type == FF_B_TYPE) {
00449                 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
00450             }
00451 
00452             mb_type = MB_TYPE_SKIP;
00453         } else {
00454             mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
00455             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
00456                 return -1;
00457             if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
00458                 return -1;
00459 
00460             mb_type = MB_TYPE_16x16;
00461         }
00462     } else if (mb_type < 8) {     /* INTER */
00463         if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
00464             mode = THIRDPEL_MODE;
00465         } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
00466             mode = HALFPEL_MODE;
00467         } else {
00468             mode = FULLPEL_MODE;
00469         }
00470 
00471         /* fill caches */
00472         /* note ref_cache should contain here:
00473             ????????
00474             ???11111
00475             N??11111
00476             N??11111
00477             N??11111
00478         */
00479 
00480         for (m = 0; m < 2; m++) {
00481             if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
00482                 for (i = 0; i < 4; i++) {
00483                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
00484                 }
00485             } else {
00486                 for (i = 0; i < 4; i++) {
00487                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
00488                 }
00489             }
00490             if (s->mb_y > 0) {
00491                 memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
00492                 memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
00493 
00494                 if (s->mb_x < (s->mb_width - 1)) {
00495                     *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
00496                     h->ref_cache[m][scan8[0] + 4 - 1*8] =
00497                         (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
00498                          h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride    ]  ] == -1) ? PART_NOT_AVAILABLE : 1;
00499                 }else
00500                     h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
00501                 if (s->mb_x > 0) {
00502                     *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
00503                     h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] == -1) ? PART_NOT_AVAILABLE : 1;
00504                 }else
00505                     h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
00506             }else
00507                 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
00508 
00509             if (s->pict_type != FF_B_TYPE)
00510                 break;
00511         }
00512 
00513         /* decode motion vector(s) and form prediction(s) */
00514         if (s->pict_type == FF_P_TYPE) {
00515             if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
00516                 return -1;
00517         } else {        /* FF_B_TYPE */
00518             if (mb_type != 2) {
00519                 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
00520                     return -1;
00521             } else {
00522                 for (i = 0; i < 4; i++) {
00523                     memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00524                 }
00525             }
00526             if (mb_type != 1) {
00527                 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
00528                     return -1;
00529             } else {
00530                 for (i = 0; i < 4; i++) {
00531                     memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00532                 }
00533             }
00534         }
00535 
00536         mb_type = MB_TYPE_16x16;
00537     } else if (mb_type == 8 || mb_type == 33) {   /* INTRA4x4 */
00538         memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
00539 
00540         if (mb_type == 8) {
00541             if (s->mb_x > 0) {
00542                 for (i = 0; i < 4; i++) {
00543                     h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
00544                 }
00545                 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
00546                     h->left_samples_available = 0x5F5F;
00547                 }
00548             }
00549             if (s->mb_y > 0) {
00550                 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
00551                 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
00552                 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
00553                 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
00554 
00555                 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
00556                     h->top_samples_available = 0x33FF;
00557                 }
00558             }
00559 
00560             /* decode prediction codes for luma blocks */
00561             for (i = 0; i < 16; i+=2) {
00562                 vlc = svq3_get_ue_golomb(&s->gb);
00563 
00564                 if (vlc >= 25){
00565                     av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
00566                     return -1;
00567                 }
00568 
00569                 left    = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
00570                 top     = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
00571 
00572                 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
00573                 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
00574 
00575                 if (left[1] == -1 || left[2] == -1){
00576                     av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
00577                     return -1;
00578                 }
00579             }
00580         } else {    /* mb_type == 33, DC_128_PRED block type */
00581             for (i = 0; i < 4; i++) {
00582                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
00583             }
00584         }
00585 
00586         ff_h264_write_back_intra_pred_mode(h);
00587 
00588         if (mb_type == 8) {
00589             ff_h264_check_intra4x4_pred_mode(h);
00590 
00591             h->top_samples_available  = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
00592             h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
00593         } else {
00594             for (i = 0; i < 4; i++) {
00595                 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
00596             }
00597 
00598             h->top_samples_available  = 0x33FF;
00599             h->left_samples_available = 0x5F5F;
00600         }
00601 
00602         mb_type = MB_TYPE_INTRA4x4;
00603     } else {                      /* INTRA16x16 */
00604         dir = i_mb_type_info[mb_type - 8].pred_mode;
00605         dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
00606 
00607         if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
00608             av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
00609             return -1;
00610         }
00611 
00612         cbp = i_mb_type_info[mb_type - 8].cbp;
00613         mb_type = MB_TYPE_INTRA16x16;
00614     }
00615 
00616     if (!IS_INTER(mb_type) && s->pict_type != FF_I_TYPE) {
00617         for (i = 0; i < 4; i++) {
00618             memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00619         }
00620         if (s->pict_type == FF_B_TYPE) {
00621             for (i = 0; i < 4; i++) {
00622                 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
00623             }
00624         }
00625     }
00626     if (!IS_INTRA4x4(mb_type)) {
00627         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
00628     }
00629     if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
00630         memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
00631         s->dsp.clear_blocks(h->mb);
00632     }
00633 
00634     if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
00635         if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
00636             av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
00637             return -1;
00638         }
00639 
00640         cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
00641     }
00642     if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
00643         s->qscale += svq3_get_se_golomb(&s->gb);
00644 
00645         if (s->qscale > 31){
00646             av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
00647             return -1;
00648         }
00649     }
00650     if (IS_INTRA16x16(mb_type)) {
00651         if (svq3_decode_block(&s->gb, h->mb, 0, 0)){
00652             av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
00653             return -1;
00654         }
00655     }
00656 
00657     if (cbp) {
00658         const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
00659         const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
00660 
00661         for (i = 0; i < 4; i++) {
00662             if ((cbp & (1 << i))) {
00663                 for (j = 0; j < 4; j++) {
00664                     k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
00665                     h->non_zero_count_cache[ scan8[k] ] = 1;
00666 
00667                     if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
00668                         av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
00669                         return -1;
00670                     }
00671                 }
00672             }
00673         }
00674 
00675         if ((cbp & 0x30)) {
00676             for (i = 0; i < 2; ++i) {
00677               if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
00678                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
00679                 return -1;
00680               }
00681             }
00682 
00683             if ((cbp & 0x20)) {
00684                 for (i = 0; i < 8; i++) {
00685                     h->non_zero_count_cache[ scan8[16+i] ] = 1;
00686 
00687                     if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
00688                         av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
00689                         return -1;
00690                     }
00691                 }
00692             }
00693         }
00694     }
00695 
00696     h->cbp= cbp;
00697     s->current_picture.mb_type[mb_xy] = mb_type;
00698 
00699     if (IS_INTRA(mb_type)) {
00700         h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
00701     }
00702 
00703     return 0;
00704 }
00705 
00706 static int svq3_decode_slice_header(H264Context *h)
00707 {
00708     MpegEncContext *const s = (MpegEncContext *) h;
00709     const int mb_xy = h->mb_xy;
00710     int i, header;
00711 
00712     header = get_bits(&s->gb, 8);
00713 
00714     if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
00715         /* TODO: what? */
00716         av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
00717         return -1;
00718     } else {
00719         int length = (header >> 5) & 3;
00720 
00721         h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
00722 
00723         if (h->next_slice_index > s->gb.size_in_bits) {
00724             av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
00725             return -1;
00726     }
00727 
00728         s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
00729         skip_bits(&s->gb, 8);
00730 
00731         if (h->svq3_watermark_key) {
00732             uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
00733             AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
00734         }
00735         if (length > 0) {
00736             memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
00737                    &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
00738         }
00739         skip_bits_long(&s->gb, 0);
00740     }
00741 
00742     if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
00743         av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
00744         return -1;
00745     }
00746 
00747     h->slice_type = golomb_to_pict_type[i];
00748 
00749     if ((header & 0x9F) == 2) {
00750         i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
00751         s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
00752     } else {
00753         skip_bits1(&s->gb);
00754         s->mb_skip_run = 0;
00755     }
00756 
00757     h->slice_num = get_bits(&s->gb, 8);
00758     s->qscale = get_bits(&s->gb, 5);
00759     s->adaptive_quant = get_bits1(&s->gb);
00760 
00761     /* unknown fields */
00762     skip_bits1(&s->gb);
00763 
00764     if (h->unknown_svq3_flag) {
00765         skip_bits1(&s->gb);
00766     }
00767 
00768     skip_bits1(&s->gb);
00769     skip_bits(&s->gb, 2);
00770 
00771     while (get_bits1(&s->gb)) {
00772         skip_bits(&s->gb, 8);
00773     }
00774 
00775     /* reset intra predictors and invalidate motion vector references */
00776     if (s->mb_x > 0) {
00777         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1      ]+3, -1, 4*sizeof(int8_t));
00778         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x]  , -1, 8*sizeof(int8_t)*s->mb_x);
00779     }
00780     if (s->mb_y > 0) {
00781         memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
00782 
00783         if (s->mb_x > 0) {
00784             h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
00785         }
00786     }
00787 
00788     return 0;
00789 }
00790 
00791 static av_cold int svq3_decode_init(AVCodecContext *avctx)
00792 {
00793     MpegEncContext *const s = avctx->priv_data;
00794     H264Context *const h = avctx->priv_data;
00795     int m;
00796     unsigned char *extradata;
00797     unsigned int size;
00798 
00799     if(avctx->thread_count > 1){
00800         av_log(avctx, AV_LOG_ERROR, "SVQ3 does not support multithreaded decoding, patch welcome! (check latest SVN too)\n");
00801         return -1;
00802     }
00803 
00804     if (ff_h264_decode_init(avctx) < 0)
00805         return -1;
00806 
00807     s->flags  = avctx->flags;
00808     s->flags2 = avctx->flags2;
00809     s->unrestricted_mv = 1;
00810     h->is_complex=1;
00811     avctx->pix_fmt = avctx->codec->pix_fmts[0];
00812 
00813     if (!s->context_initialized) {
00814         s->width  = avctx->width;
00815         s->height = avctx->height;
00816         h->halfpel_flag      = 1;
00817         h->thirdpel_flag     = 1;
00818         h->unknown_svq3_flag = 0;
00819         h->chroma_qp[0]      = h->chroma_qp[1] = 4;
00820 
00821         if (MPV_common_init(s) < 0)
00822             return -1;
00823 
00824         h->b_stride = 4*s->mb_width;
00825 
00826         ff_h264_alloc_tables(h);
00827 
00828         /* prowl for the "SEQH" marker in the extradata */
00829         extradata = (unsigned char *)avctx->extradata;
00830         for (m = 0; m < avctx->extradata_size; m++) {
00831             if (!memcmp(extradata, "SEQH", 4))
00832                 break;
00833             extradata++;
00834         }
00835 
00836         /* if a match was found, parse the extra data */
00837         if (extradata && !memcmp(extradata, "SEQH", 4)) {
00838 
00839             GetBitContext gb;
00840             int frame_size_code;
00841 
00842             size = AV_RB32(&extradata[4]);
00843             init_get_bits(&gb, extradata + 8, size*8);
00844 
00845             /* 'frame size code' and optional 'width, height' */
00846             frame_size_code = get_bits(&gb, 3);
00847             switch (frame_size_code) {
00848                 case 0: avctx->width = 160; avctx->height = 120; break;
00849                 case 1: avctx->width = 128; avctx->height =  96; break;
00850                 case 2: avctx->width = 176; avctx->height = 144; break;
00851                 case 3: avctx->width = 352; avctx->height = 288; break;
00852                 case 4: avctx->width = 704; avctx->height = 576; break;
00853                 case 5: avctx->width = 240; avctx->height = 180; break;
00854                 case 6: avctx->width = 320; avctx->height = 240; break;
00855                 case 7:
00856                     avctx->width  = get_bits(&gb, 12);
00857                     avctx->height = get_bits(&gb, 12);
00858                     break;
00859             }
00860 
00861             h->halfpel_flag  = get_bits1(&gb);
00862             h->thirdpel_flag = get_bits1(&gb);
00863 
00864             /* unknown fields */
00865             skip_bits1(&gb);
00866             skip_bits1(&gb);
00867             skip_bits1(&gb);
00868             skip_bits1(&gb);
00869 
00870             s->low_delay = get_bits1(&gb);
00871 
00872             /* unknown field */
00873             skip_bits1(&gb);
00874 
00875             while (get_bits1(&gb)) {
00876                 skip_bits(&gb, 8);
00877             }
00878 
00879             h->unknown_svq3_flag = get_bits1(&gb);
00880             avctx->has_b_frames = !s->low_delay;
00881             if (h->unknown_svq3_flag) {
00882 #if CONFIG_ZLIB
00883                 unsigned watermark_width  = svq3_get_ue_golomb(&gb);
00884                 unsigned watermark_height = svq3_get_ue_golomb(&gb);
00885                 int u1 = svq3_get_ue_golomb(&gb);
00886                 int u2 = get_bits(&gb, 8);
00887                 int u3 = get_bits(&gb, 2);
00888                 int u4 = svq3_get_ue_golomb(&gb);
00889                 unsigned buf_len = watermark_width*watermark_height*4;
00890                 int offset = (get_bits_count(&gb)+7)>>3;
00891                 uint8_t *buf;
00892 
00893                 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
00894                     return -1;
00895 
00896                 buf = av_malloc(buf_len);
00897                 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
00898                 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
00899                 if (uncompress(buf, (uLong*)&buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
00900                     av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
00901                     av_free(buf);
00902                     return -1;
00903                 }
00904                 h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
00905                 h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
00906                 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
00907                 av_free(buf);
00908 #else
00909                 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
00910                 return -1;
00911 #endif
00912             }
00913         }
00914     }
00915 
00916     return 0;
00917 }
00918 
00919 static int svq3_decode_frame(AVCodecContext *avctx,
00920                              void *data, int *data_size,
00921                              AVPacket *avpkt)
00922 {
00923     const uint8_t *buf = avpkt->data;
00924     int buf_size = avpkt->size;
00925     MpegEncContext *const s = avctx->priv_data;
00926     H264Context *const h = avctx->priv_data;
00927     int m, mb_type;
00928 
00929     /* special case for last picture */
00930     if (buf_size == 0) {
00931         if (s->next_picture_ptr && !s->low_delay) {
00932             *(AVFrame *) data = *(AVFrame *) &s->next_picture;
00933             s->next_picture_ptr = NULL;
00934             *data_size = sizeof(AVFrame);
00935         }
00936         return 0;
00937     }
00938 
00939     init_get_bits (&s->gb, buf, 8*buf_size);
00940 
00941     s->mb_x = s->mb_y = h->mb_xy = 0;
00942 
00943     if (svq3_decode_slice_header(h))
00944         return -1;
00945 
00946     s->pict_type = h->slice_type;
00947     s->picture_number = h->slice_num;
00948 
00949     if (avctx->debug&FF_DEBUG_PICT_INFO){
00950         av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
00951                av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
00952                s->adaptive_quant, s->qscale, h->slice_num);
00953     }
00954 
00955     /* for hurry_up == 5 */
00956     s->current_picture.pict_type = s->pict_type;
00957     s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
00958 
00959     /* Skip B-frames if we do not have reference frames. */
00960     if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
00961         return 0;
00962     /* Skip B-frames if we are in a hurry. */
00963     if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
00964         return 0;
00965     /* Skip everything if we are in a hurry >= 5. */
00966     if (avctx->hurry_up >= 5)
00967         return 0;
00968     if (  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
00969         ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
00970         || avctx->skip_frame >= AVDISCARD_ALL)
00971         return 0;
00972 
00973     if (s->next_p_frame_damaged) {
00974         if (s->pict_type == FF_B_TYPE)
00975             return 0;
00976         else
00977             s->next_p_frame_damaged = 0;
00978     }
00979 
00980     if (ff_h264_frame_start(h) < 0)
00981         return -1;
00982 
00983     if (s->pict_type == FF_B_TYPE) {
00984         h->frame_num_offset = (h->slice_num - h->prev_frame_num);
00985 
00986         if (h->frame_num_offset < 0) {
00987             h->frame_num_offset += 256;
00988         }
00989         if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
00990             av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
00991             return -1;
00992         }
00993     } else {
00994         h->prev_frame_num = h->frame_num;
00995         h->frame_num = h->slice_num;
00996         h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
00997 
00998         if (h->prev_frame_num_offset < 0) {
00999             h->prev_frame_num_offset += 256;
01000         }
01001     }
01002 
01003     for (m = 0; m < 2; m++){
01004         int i;
01005         for (i = 0; i < 4; i++){
01006             int j;
01007             for (j = -1; j < 4; j++)
01008                 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
01009             if (i < 3)
01010                 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
01011         }
01012     }
01013 
01014     for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
01015         for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
01016             h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
01017 
01018             if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
01019                 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
01020 
01021                 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
01022                 s->gb.size_in_bits = 8*buf_size;
01023 
01024                 if (svq3_decode_slice_header(h))
01025                     return -1;
01026 
01027                 /* TODO: support s->mb_skip_run */
01028             }
01029 
01030             mb_type = svq3_get_ue_golomb(&s->gb);
01031 
01032             if (s->pict_type == FF_I_TYPE) {
01033                 mb_type += 8;
01034             } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
01035                 mb_type += 4;
01036             }
01037             if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
01038                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
01039                 return -1;
01040             }
01041 
01042             if (mb_type != 0) {
01043                 ff_h264_hl_decode_mb (h);
01044             }
01045 
01046             if (s->pict_type != FF_B_TYPE && !s->low_delay) {
01047                 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
01048                     (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
01049             }
01050         }
01051 
01052         ff_draw_horiz_band(s, 16*s->mb_y, 16);
01053     }
01054 
01055     MPV_frame_end(s);
01056 
01057     if (s->pict_type == FF_B_TYPE || s->low_delay) {
01058         *(AVFrame *) data = *(AVFrame *) &s->current_picture;
01059     } else {
01060         *(AVFrame *) data = *(AVFrame *) &s->last_picture;
01061     }
01062 
01063     /* Do not output the last pic after seeking. */
01064     if (s->last_picture_ptr || s->low_delay) {
01065         *data_size = sizeof(AVFrame);
01066     }
01067 
01068     return buf_size;
01069 }
01070 
01071 
01072 AVCodec svq3_decoder = {
01073     "svq3",
01074     AVMEDIA_TYPE_VIDEO,
01075     CODEC_ID_SVQ3,
01076     sizeof(H264Context),
01077     svq3_decode_init,
01078     NULL,
01079     ff_h264_decode_end,
01080     svq3_decode_frame,
01081     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
01082     .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
01083     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
01084 };

Generated on Fri Sep 16 2011 17:17:43 for FFmpeg by  doxygen 1.7.1