FFmpeg: libavcodec/svq1dec.c Source File

FFmpeg

[フレーム]

libavcodec

svq1dec.c

Go to the documentation of this file.

1 /*

2 * SVQ1 decoder

3 * ported to MPlayer by Arpi <arpi@thot.banki.hu>

4 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>

5 *

8 *

10 *

11 * This file is part of FFmpeg.

12 *

13 * FFmpeg is free software; you can redistribute it and/or

14 * modify it under the terms of the GNU Lesser General Public

15 * License as published by the Free Software Foundation; either

16 * version 2.1 of the License, or (at your option) any later version.

17 *

18 * FFmpeg is distributed in the hope that it will be useful,

19 * but WITHOUT ANY WARRANTY; without even the implied warranty of

20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

21 * Lesser General Public License for more details.

22 *

23 * You should have received a copy of the GNU Lesser General Public

24 * License along with FFmpeg; if not, write to the Free Software

25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

26 */

28 /**

29 * @file

30 * Sorenson Vector Quantizer #1 (SVQ1) video codec.

31 * For more information of the SVQ1 algorithm, visit:

32 * http://www.pcisys.net/~melanson/codecs/

33 */

35 #include "libavutil/crc.h"

36 #include "libavutil/thread.h"

38 #include "avcodec.h"

39 #include "codec_internal.h"

40 #include "decode.h"

41 #include "get_bits.h"

42 #include "h263data.h"

43 #include "hpeldsp.h"

44 #include "mathops.h"

45 #include "svq1.h"

47 #define SVQ1_BLOCK_TYPE_VLC_BITS 3

48 static VLCElem svq1_block_type[8];

49 static VLCElem svq1_motion_component[176];

50 static const VLCElem *svq1_intra_multistage[6];

51 static const VLCElem *svq1_inter_multistage[6];

52 static VLCElem svq1_intra_mean[632];

53 static VLCElem svq1_inter_mean[1434];

55 /* motion vector (prediction) */

56 typedef struct svq1_pmv_s {

57 int x;

58 int y;

59 } svq1_pmv;

61 typedef struct SVQ1Context {

62 HpelDSPContext hdsp;

63 GetBitContext gb;

64 AVFrame *prev;

66 uint8_t *pkt_swapped;

67 int pkt_swapped_allocated;

69 svq1_pmv *pmv;

70 int pmv_allocated;

72 int width;

73 int height;

74 int frame_code;

75 int nonref; // 1 if the current frame won't be referenced

77 int last_tempref;

78 } SVQ1Context;

80 static const uint8_t string_table[256] = {

81 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,

82 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,

83 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,

84 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,

85 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,

86 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,

87 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,

88 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,

89 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,

90 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,

91 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,

92 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,

93 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,

94 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,

95 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,

96 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,

97 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,

98 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,

99 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,

100 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,

101 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,

102 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,

103 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,

104 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,

105 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,

106 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,

107 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,

108 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,

109 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,

110 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,

111 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,

112 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9

113 };

114

115 #define SVQ1_PROCESS_VECTOR() \

116 for (; level > 0; i++) { \

117 /* process next depth */ \

118 if (i == m) { \

119 m = n; \

120 if (--level == 0) \

121 break; \

122 } \

123 /* divide block if next bit set */ \

124 if (!get_bits1(bitbuf)) \

125 break; \

126 /* add child nodes */ \

127 list[n++] = list[i]; \

128 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\

129 }

130

131 #define SVQ1_ADD_CODEBOOK() \

132 /* add codebook entries to vector */ \

133 for (j = 0; j < stages; j++) { \

134 n3 = codebook[entries[j]] ^ 0x80808080; \

135 n1 += (n3 & 0xFF00FF00) >> 8; \

136 n2 += n3 & 0x00FF00FF; \

137 } \

138 \

139 /* clip to [0..255] */ \

140 if (n1 & 0xFF00FF00) { \

141 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

142 n1 += 0x7F007F00; \

143 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

144 n1 &= n3 & 0x00FF00FF; \

145 } \

146 \

147 if (n2 & 0xFF00FF00) { \

148 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

149 n2 += 0x7F007F00; \

150 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

151 n2 &= n3 & 0x00FF00FF; \

152 }

153

154 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \

155 codebook = (const uint32_t *)cbook[level]; \

156 if (stages > 0) \

157 bit_cache = get_bits(bitbuf, 4 * stages); \

158 /* calculate codebook entries for this vector */ \

159 for (j = 0; j < stages; j++) { \

160 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \

161 16 * j) << (level + 1); \

162 } \

163 mean -= stages * 128; \

164 n4 = (mean << 16) + mean;

165

166 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,

167 ptrdiff_t pitch)

168 {

169 uint32_t bit_cache;

170 uint8_t *list[63];

171 uint32_t *dst;

172 const uint32_t *codebook;

173 int entries[6];

174 int i, j, m, n;

175 int stages;

176 unsigned mean;

177 unsigned x, y, width, height, level;

178 uint32_t n1, n2, n3, n4;

179

180 /* initialize list for breadth first processing of vectors */

181 list[0] = pixels;

182

183 /* recursively process vector */

184 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {

185 SVQ1_PROCESS_VECTOR();

186

187 /* destination address and vector size */

188 dst = (uint32_t *)list[i];

189 width = 1 << ((4 + level) / 2);

190 height = 1 << ((3 + level) / 2);

191

192 /* get number of stages (-1 skips vector, 0 for mean only) */

193 stages = get_vlc2(bitbuf, svq1_intra_multistage[level], 4, 2) - 1;

194

195 if (stages == -1) {

196 for (y = 0; y < height; y++)

197 memset(&dst[y * (pitch / 4)], 0, width);

198 continue; /* skip vector */

199 }

200

201 if ((stages > 0 && level >= 4)) {

202 ff_dlog(NULL,

203 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",

204 stages, level);

205 return AVERROR_INVALIDDATA; /* invalid vector */

206 }

207 av_assert0(stages >= 0);

208

209 mean = get_vlc2(bitbuf, svq1_intra_mean, 8, 3);

210

211 if (stages == 0) {

212 for (y = 0; y < height; y++)

213 memset(&dst[y * (pitch / 4)], mean, width);

214 } else {

215 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);

216

217 for (y = 0; y < height; y++) {

218 for (x = 0; x < width / 4; x++, codebook++) {

219 n1 = n4;

220 n2 = n4;

221 SVQ1_ADD_CODEBOOK()

222 /* store result */

223 dst[x] = n1 << 8 | n2;

224 }

225 dst += pitch / 4;

226 }

227 }

228 }

229

230 return 0;

231 }

232

233 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,

234 ptrdiff_t pitch, int buggy)

235 {

236 uint32_t bit_cache;

237 uint8_t *list[63];

238 uint32_t *dst;

239 const uint32_t *codebook;

240 int entries[6];

241 int i, j, m, n;

242 int stages;

243 unsigned mean;

244 int x, y, width, height, level;

245 uint32_t n1, n2, n3, n4;

246

247 /* initialize list for breadth first processing of vectors */

248 list[0] = pixels;

249

250 /* recursively process vector */

251 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {

252 SVQ1_PROCESS_VECTOR();

253

254 /* destination address and vector size */

255 dst = (uint32_t *)list[i];

256 width = 1 << ((4 + level) / 2);

257 height = 1 << ((3 + level) / 2);

258

259 /* get number of stages (-1 skips vector, 0 for mean only) */

260 stages = get_vlc2(bitbuf, svq1_inter_multistage[level], 3, 2) - 1;

261

262 if (stages == -1)

263 continue; /* skip vector */

264

265 if ((stages > 0 && level >= 4)) {

266 ff_dlog(NULL,

267 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",

268 stages, level);

269 return AVERROR_INVALIDDATA; /* invalid vector */

270 }

271 av_assert0(stages >= 0);

272

273 mean = get_vlc2(bitbuf, svq1_inter_mean, 9, 3) - 256;

274

275 if (buggy) {

276 if (mean == -128)

277 mean = 128;

278 else if (mean == 128)

279 mean = -128;

280 }

281

282 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);

283

284 for (y = 0; y < height; y++) {

285 for (x = 0; x < width / 4; x++) {

286 n3 = dst[x];

287 /* add mean value to vector */

288 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);

289 n2 = n4 + (n3 & 0x00FF00FF);

290 SVQ1_ADD_CODEBOOK()

291 /* store result */

292 dst[x] = n1 << 8 | n2;

293 if (codebook != NULL)

294 codebook++;

295 }

296 dst += pitch / 4;

297 }

298 }

299 return 0;

300 }

301

302 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,

303 svq1_pmv **pmv)

304 {

305 int diff;

306 int i;

307

308 for (i = 0; i < 2; i++) {

309 /* get motion code */

310 diff = get_vlc2(bitbuf, svq1_motion_component, 7, 2);

311 if (diff < 0)

312 return AVERROR_INVALIDDATA;

313 else if (diff) {

314 if (get_bits1(bitbuf))

315 diff = -diff;

316 }

317

318 /* add median of motion vector predictors and clip result */

319 if (i == 1)

320 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);

321 else

322 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);

323 }

324

325 return 0;

326 }

327

328 static void svq1_skip_block(uint8_t *current, uint8_t *previous,

329 ptrdiff_t pitch, int x, int y)

330 {

331 uint8_t *src;

332 uint8_t *dst;

333 int i;

334

335 src = &previous[x + y * pitch];

336 dst = current;

337

338 for (i = 0; i < 16; i++) {

339 memcpy(dst, src, 16);

340 src += pitch;

341 dst += pitch;

342 }

343 }

344

345 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,

346 uint8_t *current, uint8_t *previous,

347 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,

348 int width, int height)

349 {

350 uint8_t *src;

351 uint8_t *dst;

352 svq1_pmv mv;

353 svq1_pmv *pmv[3];

354 int result;

355

356 /* predict and decode motion vector */

357 pmv[0] = &motion[0];

358 if (y == 0) {

359 pmv[1] =

360 pmv[2] = pmv[0];

361 } else {

362 pmv[1] = &motion[x / 8 + 2];

363 pmv[2] = &motion[x / 8 + 4];

364 }

365

366 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);

367 if (result)

368 return result;

369

370 motion[0].x =

371 motion[x / 8 + 2].x =

372 motion[x / 8 + 3].x = mv.x;

373 motion[0].y =

374 motion[x / 8 + 2].y =

375 motion[x / 8 + 3].y = mv.y;

376

377 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));

378 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));

379

380 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];

381 dst = current;

382

383 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);

384

385 return 0;

386 }

387

388 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,

389 uint8_t *current, uint8_t *previous,

390 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,

391 int width, int height)

392 {

393 uint8_t *src;

394 uint8_t *dst;

395 svq1_pmv mv;

396 svq1_pmv *pmv[4];

397 int i, result;

398

399 /* predict and decode motion vector (0) */

400 pmv[0] = &motion[0];

401 if (y == 0) {

402 pmv[1] =

403 pmv[2] = pmv[0];

404 } else {

405 pmv[1] = &motion[(x / 8) + 2];

406 pmv[2] = &motion[(x / 8) + 4];

407 }

408

409 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);

410 if (result)

411 return result;

412

413 /* predict and decode motion vector (1) */

414 pmv[0] = &mv;

415 if (y == 0) {

416 pmv[1] =

417 pmv[2] = pmv[0];

418 } else {

419 pmv[1] = &motion[(x / 8) + 3];

420 }

421 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);

422 if (result)

423 return result;

424

425 /* predict and decode motion vector (2) */

426 pmv[1] = &motion[0];

427 pmv[2] = &motion[(x / 8) + 1];

428

429 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);

430 if (result)

431 return result;

432

433 /* predict and decode motion vector (3) */

434 pmv[2] = &motion[(x / 8) + 2];

435 pmv[3] = &motion[(x / 8) + 3];

436

437 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);

438 if (result)

439 return result;

440

441 /* form predictions */

442 for (i = 0; i < 4; i++) {

443 int mvx = pmv[i]->x + (i & 1) * 16;

444 int mvy = pmv[i]->y + (i >> 1) * 16;

445

446 // FIXME: clipping or padding?

447 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));

448 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));

449

450 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];

451 dst = current;

452

453 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);

454

455 /* select next block */

456 if (i & 1)

457 current += 8 * (pitch - 1);

458 else

459 current += 8;

460 }

461

462 return 0;

463 }

464

465 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,

466 GetBitContext *bitbuf,

467 uint8_t *current, uint8_t *previous,

468 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,

469 int width, int height, int buggy)

470 {

471 uint32_t block_type;

472 int result = 0;

473

474 /* get block type */

475 block_type = get_vlc2(bitbuf, svq1_block_type,

476 SVQ1_BLOCK_TYPE_VLC_BITS, 1);

477

478 /* reset motion vectors */

479 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {

480 motion[0].x =

481 motion[0].y =

482 motion[x / 8 + 2].x =

483 motion[x / 8 + 2].y =

484 motion[x / 8 + 3].x =

485 motion[x / 8 + 3].y = 0;

486 }

487

488 switch (block_type) {

489 case SVQ1_BLOCK_SKIP:

490 svq1_skip_block(current, previous, pitch, x, y);

491 break;

492

493 case SVQ1_BLOCK_INTER:

494 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,

495 pitch, motion, x, y, width, height);

496

497 if (result != 0) {

498 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);

499 break;

500 }

501 result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);

502 break;

503

504 case SVQ1_BLOCK_INTER_4V:

505 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,

506 pitch, motion, x, y, width, height);

507

508 if (result != 0) {

509 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);

510 break;

511 }

512 result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);

513 break;

514

515 case SVQ1_BLOCK_INTRA:

516 result = svq1_decode_block_intra(bitbuf, current, pitch);

517 break;

518 }

519

520 return result;

521 }

522

523 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])

524 {

525 uint8_t seed;

526 int i;

527

528 out[0] = get_bits(bitbuf, 8);

529 seed = string_table[out[0]];

530

531 for (i = 1; i <= out[0]; i++) {

532 out[i] = get_bits(bitbuf, 8) ^ seed;

533 seed = string_table[out[i] ^ seed];

534 }

535 out[i] = 0;

536 }

537

538 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int * buggy)

539 {

540 SVQ1Context *s = avctx->priv_data;

541 GetBitContext *bitbuf = &s->gb;

542 int frame_size_code;

543 int width = s->width;

544 int height = s->height;

545 int tempref;

546

547 tempref = get_bits(bitbuf, 8); /* temporal_reference */

548 *buggy = tempref == 0 && s->last_tempref == 0 && avctx->extradata_size == 0;

549 s->last_tempref = tempref;

550

551 /* frame type */

552 s->nonref = 0;

553 switch (get_bits(bitbuf, 2)) {

554 case 0:

555 frame->pict_type = AV_PICTURE_TYPE_I;

556 break;

557 case 2:

558 s->nonref = 1;

559 case 1:

560 frame->pict_type = AV_PICTURE_TYPE_P;

561 break;

562 default:

563 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");

564 return AVERROR_INVALIDDATA;

565 }

566

567 if (frame->pict_type == AV_PICTURE_TYPE_I) {

568 /* unknown fields */

569 if (s->frame_code == 0x50 || s->frame_code == 0x60) {

570 int csum = get_bits(bitbuf, 16);

571

572 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));

573

574 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",

575 (csum == 0) ? "correct" : "incorrect", csum);

576 }

577

578 if ((s->frame_code ^ 0x10) >= 0x50) {

579 uint8_t msg[257];

580

581 svq1_parse_string(bitbuf, msg);

582

583 av_log(avctx, AV_LOG_INFO,

584 "embedded message:\n%s\n", ((char *)msg) + 1);

585 }

586

587 skip_bits(bitbuf, 2);

588 skip_bits(bitbuf, 2);

589 skip_bits1(bitbuf);

590

591 /* load frame size */

592 frame_size_code = get_bits(bitbuf, 3);

593

594 if (frame_size_code == 7) {

595 /* load width, height (12 bits each) */

596 width = get_bits(bitbuf, 12);

597 height = get_bits(bitbuf, 12);

598

599 if (!width || !height)

600 return AVERROR_INVALIDDATA;

601 } else {

602 /* get width, height from table */

603 width = ff_svq1_frame_size_table[frame_size_code][0];

604 height = ff_svq1_frame_size_table[frame_size_code][1];

605 }

606 }

607

608 /* unknown fields */

609 if (get_bits1(bitbuf)) {

610 skip_bits1(bitbuf); /* use packet checksum if (1) */

611 skip_bits1(bitbuf); /* component checksums after image data if (1) */

612

613 if (get_bits(bitbuf, 2) != 0)

614 return AVERROR_INVALIDDATA;

615 }

616

617 if (get_bits1(bitbuf)) {

618 skip_bits1(bitbuf);

619 skip_bits(bitbuf, 4);

620 skip_bits1(bitbuf);

621 skip_bits(bitbuf, 2);

622

623 if (skip_1stop_8data_bits(bitbuf) < 0)

624 return AVERROR_INVALIDDATA;

625 }

626 if (get_bits_left(bitbuf) <= 0)

627 return AVERROR_INVALIDDATA;

628

629 s->width = width;

630 s->height = height;

631 return 0;

632 }

633

634 static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur,

635 int *got_frame, AVPacket *avpkt)

636 {

637 const uint8_t *buf = avpkt->data;

638 int buf_size = avpkt->size;

639 SVQ1Context *s = avctx->priv_data;

640 uint8_t *current;

641 int result, i, x, y, width, height, buggy;

642 int ret;

643

644 /* initialize bit buffer */

645 ret = init_get_bits8(&s->gb, buf, buf_size);

646 if (ret < 0)

647 return ret;

648

649 /* decode frame header */

650 s->frame_code = get_bits(&s->gb, 22);

651

652 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))

653 return AVERROR_INVALIDDATA;

654

655 /* swap some header bytes (why?) */

656 if (s->frame_code != 0x20) {

657 uint32_t *src;

658

659 if (buf_size < 9 * 4) {

660 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");

661 return AVERROR_INVALIDDATA;

662 }

663

664 av_fast_padded_malloc(&s->pkt_swapped,

665 &s->pkt_swapped_allocated,

666 buf_size);

667 if (!s->pkt_swapped)

668 return AVERROR(ENOMEM);

669

670 memcpy(s->pkt_swapped, buf, buf_size);

671 buf = s->pkt_swapped;

672 init_get_bits(&s->gb, buf, buf_size * 8);

673 skip_bits(&s->gb, 22);

674

675 src = (uint32_t *)(s->pkt_swapped + 4);

676

677 for (i = 0; i < 4; i++)

678 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];

679 }

680

681 result = svq1_decode_frame_header(avctx, cur, &buggy);

682 if (result != 0) {

683 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);

684 return result;

685 }

686

687 result = ff_set_dimensions(avctx, s->width, s->height);

688 if (result < 0)

689 return result;

690

691 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||

692 (avctx->skip_frame >= AVDISCARD_NONKEY &&

693 cur->pict_type != AV_PICTURE_TYPE_I) ||

694 avctx->skip_frame >= AVDISCARD_ALL)

695 return buf_size;

696

697 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);

698 if (result < 0)

699 return result;

700

701 av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));

702 if (!s->pmv)

703 return AVERROR(ENOMEM);

704

705 /* decode y, u and v components */

706 for (i = 0; i < 3; i++) {

707 int linesize = cur->linesize[i];

708 if (i == 0) {

709 width = FFALIGN(s->width, 16);

710 height = FFALIGN(s->height, 16);

711 } else {

712 if (avctx->flags & AV_CODEC_FLAG_GRAY)

713 break;

714 width = FFALIGN(s->width / 4, 16);

715 height = FFALIGN(s->height / 4, 16);

716 }

717

718 current = cur->data[i];

719

720 if (cur->pict_type == AV_PICTURE_TYPE_I) {

721 /* keyframe */

722 for (y = 0; y < height; y += 16) {

723 for (x = 0; x < width; x += 16) {

724 result = svq1_decode_block_intra(&s->gb, &current[x],

725 linesize);

726 if (result) {

727 av_log(avctx, AV_LOG_ERROR,

728 "Error in svq1_decode_block %i (keyframe)\n",

729 result);

730 return result;

731 }

732 }

733 current += 16 * linesize;

734 }

735 } else {

736 /* delta frame */

737 uint8_t *previous = s->prev->data[i];

738 if (!previous ||

739 s->prev->width != s->width || s->prev->height != s->height) {

740 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");

741 return AVERROR_INVALIDDATA;

742 }

743

744 memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));

745

746 for (y = 0; y < height; y += 16) {

747 for (x = 0; x < width; x += 16) {

748 result = svq1_decode_delta_block(avctx, &s->hdsp,

749 &s->gb, &current[x],

750 previous, linesize,

751 s->pmv, x, y, width, height, buggy);

752 if (result != 0) {

753 ff_dlog(avctx,

754 "Error in svq1_decode_delta_block %i\n",

755 result);

756 return result;

757 }

758 }

759

760 s->pmv[0].x =

761 s->pmv[0].y = 0;

762

763 current += 16 * linesize;

764 }

765 }

766 }

767

768 if (!s->nonref) {

769 result = av_frame_replace(s->prev, cur);

770 if (result < 0)

771 return result;

772 }

773

774 *got_frame = 1;

775 result = buf_size;

776

777 return result;

778 }

779

780 static av_cold void svq1_static_init(void)

781 {

782 static VLCElem table[196];

783 VLCInitState state = VLC_INIT_STATE(table);

784

785 VLC_INIT_STATIC_TABLE(svq1_block_type, SVQ1_BLOCK_TYPE_VLC_BITS, 4,

786 &ff_svq1_block_type_vlc[0][1], 2, 1,

787 &ff_svq1_block_type_vlc[0][0], 2, 1, 0);

788

789 VLC_INIT_STATIC_TABLE(svq1_motion_component, 7, 33,

790 &ff_mvtab[0][1], 2, 1,

791 &ff_mvtab[0][0], 2, 1, 0);

792

793 for (int i = 0; i < 6; i++) {

794 svq1_intra_multistage[i] =

795 ff_vlc_init_tables(&state, 4, 8,

796 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,

797 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 0);

798 svq1_inter_multistage[i] =

799 ff_vlc_init_tables(&state, 3, 8,

800 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,

801 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 0);

802 }

803

804 VLC_INIT_STATIC_TABLE(svq1_intra_mean, 8, 256,

805 &ff_svq1_intra_mean_vlc[0][1], 4, 2,

806 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 0);

807

808 VLC_INIT_STATIC_TABLE(svq1_inter_mean, 9, 512,

809 &ff_svq1_inter_mean_vlc[0][1], 4, 2,

810 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 0);

811 }

812

813 static av_cold int svq1_decode_init(AVCodecContext *avctx)

814 {

815 static AVOnce init_static_once = AV_ONCE_INIT;

816 SVQ1Context *s = avctx->priv_data;

817

818 s->prev = av_frame_alloc();

819 if (!s->prev)

820 return AVERROR(ENOMEM);

821

822 s->width = avctx->width + 3 & ~3;

823 s->height = avctx->height + 3 & ~3;

824 avctx->pix_fmt = AV_PIX_FMT_YUV410P;

825

826 ff_hpeldsp_init(&s->hdsp, avctx->flags);

827

828 ff_thread_once(&init_static_once, svq1_static_init);

829

830 s->last_tempref = 0xFF;

831

832 return 0;

833 }

834

835 static av_cold int svq1_decode_end(AVCodecContext *avctx)

836 {

837 SVQ1Context *s = avctx->priv_data;

838

839 av_frame_free(&s->prev);

840 av_freep(&s->pkt_swapped);

841 s->pkt_swapped_allocated = 0;

842 av_freep(&s->pmv);

843 s->pmv_allocated = 0;

844

845 return 0;

846 }

847

848 static void svq1_flush(AVCodecContext *avctx)

849 {

850 SVQ1Context *s = avctx->priv_data;

851

852 av_frame_unref(s->prev);

853 }

854

855 const FFCodec ff_svq1_decoder = {

856 .p.name = "svq1",

857 CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),

858 .p.type = AVMEDIA_TYPE_VIDEO,

859 .p.id = AV_CODEC_ID_SVQ1,

860 .priv_data_size = sizeof(SVQ1Context),

861 .init = svq1_decode_init,

862 .close = svq1_decode_end,

863 FF_CODEC_DECODE_CB(svq1_decode_frame),

864 .p.capabilities = AV_CODEC_CAP_DR1,

865 .flush = svq1_flush,

866 };

h263data.h

level

uint8_t level

Definition: svq3.c:204

av_clip

#define av_clip

Definition: common.h:98

svq1_static_init

static av_cold void svq1_static_init(void)

Definition: svq1dec.c:780

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

out

FILE * out

Definition: movenc.c:54

svq1_block_type

static VLCElem svq1_block_type[8]

Definition: svq1dec.c:48

svq1_decode_block_non_intra

static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch, int buggy)

Definition: svq1dec.c:233

thread.h

ff_svq1_inter_codebooks

const FF_VISIBILITY_PUSH_HIDDEN int8_t *const ff_svq1_inter_codebooks[6]

Definition: svq1_cb.h:776

SVQ1Context::last_tempref

int last_tempref

Definition: svq1dec.c:77

SVQ1Context::height

int height

Definition: svq1dec.c:73

static const int8_t mv[256][2]

Definition: 4xm.c:80

ff_svq1_intra_codebooks

const int8_t *const ff_svq1_intra_codebooks[6]

Definition: svq1_cb.h:1519

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:111

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:130

svq1_inter_multistage

static const VLCElem * svq1_inter_multistage[6]

Definition: svq1dec.c:51

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:344

AVPacket::data

uint8_t * data

Definition: packet.h:522

table

static const uint16_t table[]

Definition: prosumer.c:205

FFCodec

Definition: codec_internal.h:127

svq1_skip_block

static void svq1_skip_block(uint8_t *current, uint8_t *previous, ptrdiff_t pitch, int x, int y)

Definition: svq1dec.c:328

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:94

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:514

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:365

ff_svq1_intra_multistage_vlc

const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]

Definition: svq1_vlc.h:33

crc.h

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:381

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:335

ff_svq1_inter_mean_vlc

const uint16_t ff_svq1_inter_mean_vlc[512][2]

Definition: svq1_vlc.h:136

svq1_decode_block_intra

static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)

Definition: svq1dec.c:166

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

SVQ1_CALC_CODEBOOK_ENTRIES

#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)

Definition: svq1dec.c:154

AVCodecContext::skip_frame

enum AVDiscard skip_frame

Skip decoding for selected frames.

Definition: avcodec.h:1819

GetBitContext

Definition: get_bits.h:108

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:502

svq1_decode_end

static av_cold int svq1_decode_end(AVCodecContext *avctx)

Definition: svq1dec.c:835

svq1_pmv_s::x

int x

Definition: svq1dec.c:57

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:118

SVQ1_BLOCK_TYPE_VLC_BITS

#define SVQ1_BLOCK_TYPE_VLC_BITS

Definition: svq1dec.c:47

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:545

SVQ1Context::hdsp

HpelDSPContext hdsp

Definition: svq1dec.c:62

VLCInitState

For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.

Definition: vlc.h:209

svq1_decode_frame

static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, int *got_frame, AVPacket *avpkt)

Definition: svq1dec.c:634

SVQ1Context::gb

GetBitContext gb

Definition: svq1dec.c:63

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:524

svq1_inter_mean

static VLCElem svq1_inter_mean[1434]

Definition: svq1dec.c:53

width

#define width

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:287

#define s(width, name)

Definition: cbs_vp9.c:198

AV_GET_BUFFER_FLAG_REF

#define AV_GET_BUFFER_FLAG_REF

The decoder will keep a reference to the frame and may reuse it later.

Definition: avcodec.h:425

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

decode.h

get_bits.h

SVQ1Context

Definition: svq1dec.c:61

SVQ1Context::pmv

svq1_pmv * pmv

Definition: svq1dec.c:69

svq1_motion_inter_block

static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)

Definition: svq1dec.c:345

SVQ1Context::frame_code

int frame_code

Definition: svq1dec.c:74

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

frame

static AVFrame * frame

Definition: demux_decode.c:54

ff_hpeldsp_init

av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)

Definition: hpeldsp.c:338

SVQ1_ADD_CODEBOOK

#define SVQ1_ADD_CODEBOOK()

Definition: svq1dec.c:131

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:219

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:109

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

result

and forward the result(frame or status change) to the corresponding input. If nothing is possible

NULL

#define NULL

Definition: coverity.c:32

SVQ1_BLOCK_INTRA

#define SVQ1_BLOCK_INTRA

Definition: svq1.h:45

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

mathops.h

list

Definition: filter_design.txt:25

state

static struct @385 state

SVQ1_BLOCK_SKIP

#define SVQ1_BLOCK_SKIP

Definition: svq1.h:42

seed

static unsigned int seed

Definition: videogen.c:78

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:652

AVOnce

#define AVOnce

Definition: thread.h:202

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

HpelDSPContext

Half-pel DSP context.

Definition: hpeldsp.h:45

AVDISCARD_NONKEY

@ AVDISCARD_NONKEY

discard all frames except keyframes

Definition: defs.h:218

HpelDSPContext::put_pixels_tab

op_pixels_func put_pixels_tab[4][4]

Halfpel motion compensation with rounding (a+b+1)>>1.

Definition: hpeldsp.h:56

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1569

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:446

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:365

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:322

AVPacket::size

int size

Definition: packet.h:523

codec_internal.h

VLCElem

Definition: vlc.h:32

SVQ1_BLOCK_INTER_4V

#define SVQ1_BLOCK_INTER_4V

Definition: svq1.h:44

svq1_flush

static void svq1_flush(AVCodecContext *avctx)

Definition: svq1dec.c:848

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:164

height

#define height

av_crc_get_table

const AVCRC * av_crc_get_table(AVCRCId crc_id)

Get an initialized standard CRC table.

Definition: crc.c:374

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:413

AV_CODEC_ID_SVQ1

@ AV_CODEC_ID_SVQ1

Definition: codec_id.h:74

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

AV_CRC_16_CCITT

@ AV_CRC_16_CCITT

Definition: crc.h:51

string_table

static const uint8_t string_table[256]

Definition: svq1dec.c:80

av_fast_padded_malloc

void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)

Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...

Definition: utils.c:52

svq1_decode_frame_header

static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int *buggy)

Definition: svq1dec.c:538

SVQ1_PROCESS_VECTOR

#define SVQ1_PROCESS_VECTOR()

Definition: svq1dec.c:115

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:576

SVQ1Context::nonref

int nonref

Definition: svq1dec.c:75

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

AVCodecContext::height

int height

Definition: avcodec.h:618

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:657

SVQ1_BLOCK_INTER

#define SVQ1_BLOCK_INTER

Definition: svq1.h:43

avcodec.h

svq1_parse_string

static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])

Definition: svq1dec.c:523

svq1_intra_mean

static VLCElem svq1_intra_mean[632]

Definition: svq1dec.c:52

ff_svq1_inter_multistage_vlc

const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]

Definition: svq1_vlc.h:50

mid_pred

#define mid_pred

Definition: mathops.h:98

SVQ1Context::prev

AVFrame * prev

Definition: svq1dec.c:64

ret

Definition: filter_design.txt:187

svq1_decode_delta_block

static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height, int buggy)

Definition: svq1dec.c:465

ff_mvtab

const uint8_t ff_mvtab[33][2]

Definition: h263data.c:88

av_frame_replace

int av_frame_replace(AVFrame *dst, const AVFrame *src)

Ensure the destination frame refers to the same data described by the source frame,...

Definition: frame.c:453

skip_1stop_8data_bits

static int skip_1stop_8data_bits(GetBitContext *gb)

Definition: get_bits.h:700

AVCodecContext

main external API structure.

Definition: avcodec.h:445

svq1_decode_motion_vector

static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)

Definition: svq1dec.c:302

ff_svq1_block_type_vlc

const uint8_t ff_svq1_block_type_vlc[4][2]

Definition: svq1_vlc.h:27

ff_svq1_intra_mean_vlc

const uint16_t ff_svq1_intra_mean_vlc[256][2]

Definition: svq1_vlc.h:67

av_crc

uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)

Calculate the CRC of a block.

Definition: crc.c:392

VLC_INIT_STATIC_TABLE

#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:267

SVQ1Context::width

int width

Definition: svq1dec.c:72

SVQ1Context::pkt_swapped_allocated

int pkt_swapped_allocated

Definition: svq1dec.c:67

svq1.h

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:133

mean

static float mean(const float *input, int size)

Definition: vf_nnedi.c:862

svq1_decode_init

static av_cold int svq1_decode_init(AVCodecContext *avctx)

Definition: svq1dec.c:813

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:280

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

ff_vlc_init_tables

static const VLCElem * ff_vlc_init_tables(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, int flags)

Definition: vlc.h:243

SVQ1Context::pmv_allocated

int pmv_allocated

Definition: svq1dec.c:70

svq1_motion_component

static VLCElem svq1_motion_component[176]

Definition: svq1dec.c:49

SVQ1Context::pkt_swapped

uint8_t * pkt_swapped

Definition: svq1dec.c:66

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

VLC_INIT_STATE

#define VLC_INIT_STATE(_table)

Definition: vlc.h:214

AVPacket

This structure stores compressed data.

Definition: packet.h:499

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:472

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

svq1_motion_inter_4v_block

static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)

Definition: svq1dec.c:388

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:618

hpeldsp.h

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, a positive or negative value, which is typically indicating the size in bytes of each pict...

Definition: frame.h:389

AV_PIX_FMT_YUV410P

@ AV_PIX_FMT_YUV410P