Libav
|
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 };