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 VLC svq1_block_type;

49 static VLC svq1_motion_component;

50 static VLC svq1_intra_multistage[6];

51 static VLC svq1_inter_multistage[6];

52 static VLC svq1_intra_mean;

53 static VLC svq1_inter_mean;

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].table, 3, 3) - 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.table, 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].table, 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.table, 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++, codebook++) {

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 }

294 dst += pitch / 4;

295 }

296 }

297 return 0;

298 }

299

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

301 svq1_pmv **pmv)

302 {

303 int diff;

304 int i;

305

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

307 /* get motion code */

308 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);

309 if (diff < 0)

310 return AVERROR_INVALIDDATA;

311 else if (diff) {

312 if (get_bits1(bitbuf))

313 diff = -diff;

314 }

315

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

317 if (i == 1)

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

319 else

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

321 }

322

323 return 0;

324 }

325

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

327 ptrdiff_t pitch, int x, int y)

328 {

329 uint8_t *src;

330 uint8_t *dst;

331 int i;

332

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

334 dst = current;

335

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

337 memcpy(dst, src, 16);

338 src += pitch;

339 dst += pitch;

340 }

341 }

342

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

344 uint8_t *current, uint8_t *previous,

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

346 int width, int height)

347 {

348 uint8_t *src;

349 uint8_t *dst;

350 svq1_pmv mv;

351 svq1_pmv *pmv[3];

352 int result;

353

354 /* predict and decode motion vector */

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

356 if (y == 0) {

357 pmv[1] =

358 pmv[2] = pmv[0];

359 } else {

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

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

362 }

363

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

365 if (result)

366 return result;

367

368 motion[0].x =

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

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

371 motion[0].y =

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

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

374

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

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

377

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

379 dst = current;

380

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

382

383 return 0;

384 }

385

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

387 uint8_t *current, uint8_t *previous,

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

389 int width, int height)

390 {

391 uint8_t *src;

392 uint8_t *dst;

393 svq1_pmv mv;

394 svq1_pmv *pmv[4];

395 int i, result;

396

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

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

399 if (y == 0) {

400 pmv[1] =

401 pmv[2] = pmv[0];

402 } else {

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

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

405 }

406

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

408 if (result)

409 return result;

410

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

412 pmv[0] = &mv;

413 if (y == 0) {

414 pmv[1] =

415 pmv[2] = pmv[0];

416 } else {

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

418 }

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

420 if (result)

421 return result;

422

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

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

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

426

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

428 if (result)

429 return result;

430

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

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

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

434

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

436 if (result)

437 return result;

438

439 /* form predictions */

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

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

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

443

444 // FIXME: clipping or padding?

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

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

447

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

449 dst = current;

450

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

452

453 /* select next block */

454 if (i & 1)

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

456 else

457 current += 8;

458 }

459

460 return 0;

461 }

462

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

464 GetBitContext *bitbuf,

465 uint8_t *current, uint8_t *previous,

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

467 int width, int height, int buggy)

468 {

469 uint32_t block_type;

470 int result = 0;

471

472 /* get block type */

473 block_type = get_vlc2(bitbuf, svq1_block_type.table,

474 SVQ1_BLOCK_TYPE_VLC_BITS, 1);

475

476 /* reset motion vectors */

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

478 motion[0].x =

479 motion[0].y =

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

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

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

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

484 }

485

486 switch (block_type) {

487 case SVQ1_BLOCK_SKIP:

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

489 break;

490

491 case SVQ1_BLOCK_INTER:

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

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

494

495 if (result != 0) {

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

497 break;

498 }

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

500 break;

501

502 case SVQ1_BLOCK_INTER_4V:

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

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

505

506 if (result != 0) {

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

508 break;

509 }

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

511 break;

512

513 case SVQ1_BLOCK_INTRA:

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

515 break;

516 }

517

518 return result;

519 }

520

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

522 {

523 uint8_t seed;

524 int i;

525

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

527 seed = string_table[out[0]];

528

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

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

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

532 }

533 out[i] = 0;

534 }

535

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

537 {

538 SVQ1Context *s = avctx->priv_data;

539 GetBitContext *bitbuf = &s->gb;

540 int frame_size_code;

541 int width = s->width;

542 int height = s->height;

543 int tempref;

544

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

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

547 s->last_tempref = tempref;

548

549 /* frame type */

550 s->nonref = 0;

551 switch (get_bits(bitbuf, 2)) {

552 case 0:

553 frame->pict_type = AV_PICTURE_TYPE_I;

554 break;

555 case 2:

556 s->nonref = 1;

557 case 1:

558 frame->pict_type = AV_PICTURE_TYPE_P;

559 break;

560 default:

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

562 return AVERROR_INVALIDDATA;

563 }

564

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

566 /* unknown fields */

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

568 int csum = get_bits(bitbuf, 16);

569

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

571

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

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

574 }

575

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

577 uint8_t msg[257];

578

579 svq1_parse_string(bitbuf, msg);

580

581 av_log(avctx, AV_LOG_INFO,

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

583 }

584

585 skip_bits(bitbuf, 2);

586 skip_bits(bitbuf, 2);

587 skip_bits1(bitbuf);

588

589 /* load frame size */

590 frame_size_code = get_bits(bitbuf, 3);

591

592 if (frame_size_code == 7) {

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

594 width = get_bits(bitbuf, 12);

595 height = get_bits(bitbuf, 12);

596

597 if (!width || !height)

598 return AVERROR_INVALIDDATA;

599 } else {

600 /* get width, height from table */

601 width = ff_svq1_frame_size_table[frame_size_code][0];

602 height = ff_svq1_frame_size_table[frame_size_code][1];

603 }

604 }

605

606 /* unknown fields */

607 if (get_bits1(bitbuf)) {

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

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

610

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

612 return AVERROR_INVALIDDATA;

613 }

614

615 if (get_bits1(bitbuf)) {

616 skip_bits1(bitbuf);

617 skip_bits(bitbuf, 4);

618 skip_bits1(bitbuf);

619 skip_bits(bitbuf, 2);

620

621 if (skip_1stop_8data_bits(bitbuf) < 0)

622 return AVERROR_INVALIDDATA;

623 }

624 if (get_bits_left(bitbuf) <= 0)

625 return AVERROR_INVALIDDATA;

626

627 s->width = width;

628 s->height = height;

629 return 0;

630 }

631

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

633 int *got_frame, AVPacket *avpkt)

634 {

635 const uint8_t *buf = avpkt->data;

636 int buf_size = avpkt->size;

637 SVQ1Context *s = avctx->priv_data;

638 uint8_t *current;

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

640 int ret;

641

642 /* initialize bit buffer */

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

644 if (ret < 0)

645 return ret;

646

647 /* decode frame header */

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

649

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

651 return AVERROR_INVALIDDATA;

652

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

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

655 uint32_t *src;

656

657 if (buf_size < 9 * 4) {

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

659 return AVERROR_INVALIDDATA;

660 }

661

662 av_fast_padded_malloc(&s->pkt_swapped,

663 &s->pkt_swapped_allocated,

664 buf_size);

665 if (!s->pkt_swapped)

666 return AVERROR(ENOMEM);

667

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

669 buf = s->pkt_swapped;

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

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

672

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

674

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

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

677 }

678

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

680 if (result != 0) {

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

682 return result;

683 }

684

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

686 if (result < 0)

687 return result;

688

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

690 (avctx->skip_frame >= AVDISCARD_NONKEY &&

691 cur->pict_type != AV_PICTURE_TYPE_I) ||

692 avctx->skip_frame >= AVDISCARD_ALL)

693 return buf_size;

694

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

696 if (result < 0)

697 return result;

698

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

700 if (!s->pmv)

701 return AVERROR(ENOMEM);

702

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

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

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

706 if (i == 0) {

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

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

709 } else {

710 if (avctx->flags & AV_CODEC_FLAG_GRAY)

711 break;

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

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

714 }

715

716 current = cur->data[i];

717

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

719 /* keyframe */

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

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

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

723 linesize);

724 if (result) {

725 av_log(avctx, AV_LOG_ERROR,

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

727 result);

728 return result;

729 }

730 }

731 current += 16 * linesize;

732 }

733 } else {

734 /* delta frame */

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

736 if (!previous ||

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

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

739 return AVERROR_INVALIDDATA;

740 }

741

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

743

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

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

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

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

748 previous, linesize,

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

750 if (result != 0) {

751 ff_dlog(avctx,

752 "Error in svq1_decode_delta_block %i\n",

753 result);

754 return result;

755 }

756 }

757

758 s->pmv[0].x =

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

760

761 current += 16 * linesize;

762 }

763 }

764 }

765

766 if (!s->nonref) {

767 av_frame_unref(s->prev);

768 result = av_frame_ref(s->prev, cur);

769 if (result < 0)

770 return result;

771 }

772

773 *got_frame = 1;

774 result = buf_size;

775

776 return result;

777 }

778

779 static av_cold void svq1_static_init(void)

780 {

781 INIT_VLC_STATIC(&svq1_block_type, SVQ1_BLOCK_TYPE_VLC_BITS, 4,

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

783 &ff_svq1_block_type_vlc[0][0], 2, 1, 8);

784

785 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,

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

787 &ff_mvtab[0][0], 2, 1, 176);

788

789 for (int i = 0, offset = 0; i < 6; i++) {

790 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },

791 { 10, 10, 14, 14, 14, 16 } };

792 static VLCElem table[168];

793 svq1_intra_multistage[i].table = &table[offset];

794 svq1_intra_multistage[i].table_allocated = sizes[0][i];

795 offset += sizes[0][i];

796 init_vlc(&svq1_intra_multistage[i], 3, 8,

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

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

799 INIT_VLC_USE_NEW_STATIC);

800 svq1_inter_multistage[i].table = &table[offset];

801 svq1_inter_multistage[i].table_allocated = sizes[1][i];

802 offset += sizes[1][i];

803 init_vlc(&svq1_inter_multistage[i], 3, 8,

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

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

806 INIT_VLC_USE_NEW_STATIC);

807 }

808

809 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,

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

811 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);

812

813 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,

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

815 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);

816 }

817

818 static av_cold int svq1_decode_init(AVCodecContext *avctx)

819 {

820 static AVOnce init_static_once = AV_ONCE_INIT;

821 SVQ1Context *s = avctx->priv_data;

822

823 s->prev = av_frame_alloc();

824 if (!s->prev)

825 return AVERROR(ENOMEM);

826

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

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

829 avctx->pix_fmt = AV_PIX_FMT_YUV410P;

830

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

832

833 ff_thread_once(&init_static_once, svq1_static_init);

834

835 s->last_tempref = 0xFF;

836

837 return 0;

838 }

839

840 static av_cold int svq1_decode_end(AVCodecContext *avctx)

841 {

842 SVQ1Context *s = avctx->priv_data;

843

844 av_frame_free(&s->prev);

845 av_freep(&s->pkt_swapped);

846 s->pkt_swapped_allocated = 0;

847 av_freep(&s->pmv);

848 s->pmv_allocated = 0;

849

850 return 0;

851 }

852

853 static void svq1_flush(AVCodecContext *avctx)

854 {

855 SVQ1Context *s = avctx->priv_data;

856

857 av_frame_unref(s->prev);

858 }

859

860 const FFCodec ff_svq1_decoder = {

861 .p.name = "svq1",

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

863 .p.type = AVMEDIA_TYPE_VIDEO,

864 .p.id = AV_CODEC_ID_SVQ1,

865 .priv_data_size = sizeof(SVQ1Context),

866 .init = svq1_decode_init,

867 .close = svq1_decode_end,

868 FF_CODEC_DECODE_CB(svq1_decode_frame),

869 .p.capabilities = AV_CODEC_CAP_DR1,

870 .flush = svq1_flush,

871 .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,

872 AV_PIX_FMT_NONE },

873 };

svq1_inter_multistage

static VLC svq1_inter_multistage[6]

Definition: svq1dec.c:51

h263data.h

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

level

uint8_t level

Definition: svq3.c:204

av_clip

#define av_clip

Definition: common.h:95

svq1_static_init

static av_cold void svq1_static_init(void)

Definition: svq1dec.c:779

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:664

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_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

INIT_VLC_STATIC

#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)

Definition: vlc.h:125

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

svq1_intra_multistage

static VLC svq1_intra_multistage[6]

Definition: svq1dec.c:50

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:110

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:99

AVFrame

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

Definition: frame.h:330

AVPacket::data

uint8_t * data

Definition: packet.h:374

init_vlc

#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:43

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:326

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:91

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:493

svq1_intra_mean

static VLC svq1_intra_mean

Definition: svq1dec.c:52

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:351

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:371

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:325

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:1713

GetBitContext

Definition: get_bits.h:107

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:506

svq1_decode_end

static av_cold int svq1_decode_end(AVCodecContext *avctx)

Definition: svq1dec.c:840

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:87

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:184

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:524

SVQ1Context::hdsp

HpelDSPContext hdsp

Definition: svq1dec.c:62

svq1_decode_frame

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

Definition: svq1dec.c:632

SVQ1Context::gb

GetBitContext gb

Definition: svq1dec.c:63

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:528

width

#define width

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:306

#define s(width, name)

Definition: cbs_vp9.c:256

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:404

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

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:343

SVQ1Context::frame_code

int frame_code

Definition: svq1dec.c:74

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

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:76

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:108

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:182

result

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

NULL

#define NULL

Definition: coverity.c:32

sizes

static const int sizes[][2]

Definition: img2dec.c:57

SVQ1_BLOCK_INTRA

#define SVQ1_BLOCK_INTRA

Definition: svq1.h:45

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:378

mathops.h

list

Definition: filter_design.txt:25

INIT_VLC_USE_NEW_STATIC

#define INIT_VLC_USE_NEW_STATIC

Definition: vlc.h:100

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:631

AVOnce

#define AVOnce

Definition: thread.h:181

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

HpelDSPContext

Half-pel DSP context.

Definition: hpeldsp.h:45

VLC::table_allocated

int table_allocated

Definition: vlc.h:34

AVDISCARD_NONKEY

@ AVDISCARD_NONKEY

discard all frames except keyframes

Definition: defs.h:75

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:1473

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:427

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:301

AVPacket::size

int size

Definition: packet.h:375

av_frame_ref

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

Set up a new reference to the data described by the source frame.

Definition: frame.c:344

codec_internal.h

VLCElem

Definition: vlc.h:27

SVQ1_BLOCK_INTER_4V

#define SVQ1_BLOCK_INTER_4V

Definition: svq1.h:44

svq1_flush

static void svq1_flush(AVCodecContext *avctx)

Definition: svq1dec.c:853

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:162

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

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

av_bswap16

#define av_bswap16

Definition: bswap.h:31

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:403

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:269

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:49

svq1_decode_frame_header

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

Definition: svq1dec.c:536

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:478

SVQ1Context::nonref

int nonref

Definition: svq1dec.c:75

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

svq1_inter_mean

static VLC svq1_inter_mean

Definition: svq1dec.c:53

AVCodecContext::height

int height

Definition: avcodec.h:598

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:635

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:521

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

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

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:463

ff_mvtab

const uint8_t ff_mvtab[33][2]

Definition: h263data.c:88

skip_1stop_8data_bits

static int skip_1stop_8data_bits(GetBitContext *gb)

Definition: get_bits.h:669

AVCodecContext

main external API structure.

Definition: avcodec.h:426

svq1_decode_motion_vector

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

Definition: svq1dec.c:300

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

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

VLC

Definition: vlc.h:31

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

VLC::table

VLCElem * table

Definition: vlc.h:33

mean

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

Definition: vf_nnedi.c:857

svq1_decode_init

static av_cold int svq1_decode_init(AVCodecContext *avctx)

Definition: svq1dec.c:818

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:275

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

SVQ1Context::pmv_allocated

int pmv_allocated

Definition: svq1dec.c:70

svq1_block_type

static VLC svq1_block_type

Definition: svq1dec.c:48

SVQ1Context::pkt_swapped

uint8_t * pkt_swapped

Definition: svq1dec.c:66

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

AVPacket

This structure stores compressed data.

Definition: packet.h:351

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:453

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:386

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:598

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:375

AV_PIX_FMT_YUV410P

@ AV_PIX_FMT_YUV410P