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