FFmpeg: libavcodec/mss4.c Source File

FFmpeg

[フレーム]

libavcodec

mss4.c

Go to the documentation of this file.

1 /*

2 * Microsoft Screen 4 (aka Microsoft Expression Encoder Screen) decoder

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * Microsoft Screen 4 (aka Microsoft Titanium Screen 2,

25 * aka Microsoft Expression Encoder Screen) decoder

26 */

28 #include "avcodec.h"

29 #include "bytestream.h"

30 #include "dsputil.h"

31 #include "get_bits.h"

32 #include "internal.h"

33 #include "mss34dsp.h"

34 #include "unary.h"

36 #define HEADER_SIZE 8

38 enum FrameType {

39 INTRA_FRAME = 0,

40 INTER_FRAME,

41 SKIP_FRAME

42 };

44 enum BlockType {

45 SKIP_BLOCK = 0,

46 DCT_BLOCK,

47 IMAGE_BLOCK,

48 };

50 enum CachePos {

51 LEFT = 0,

52 TOP_LEFT,

53 TOP,

54 };

56 static const uint8_t mss4_dc_vlc_lens[2][16] = {

57 { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },

58 { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }

59 };

61 static const uint8_t mss4_ac_vlc_lens[2][16] = {

62 { 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125 },

63 { 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119 }

64 };

66 static const uint8_t mss4_ac_vlc_syms[2][162] = {

67 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,

68 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,

69 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,

70 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,

71 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,

72 0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,

73 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,

74 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,

75 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,

76 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,

77 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,

78 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,

79 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,

80 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,

81 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,

82 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,

83 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,

84 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,

85 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,

86 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,

87 0xF9, 0xFA },

88 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,

89 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,

90 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,

91 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,

92 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,

93 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,

94 0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,

95 0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,

96 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,

97 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,

98 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,

99 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

100 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,

101 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,

102 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,

103 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,

104 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,

105 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,

106 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,

107 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,

108 0xF9, 0xFA }

109 };

110

111 static const uint8_t vec_len_syms[2][4] = {

112 { 4, 2, 3, 1 },

113 { 4, 1, 2, 3 }

114 };

115

116 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {

117 { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },

118 { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }

119 };

120

121 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {

122 { 0, 7, 6, 5, 8, 4, 3, 1, 2 },

123 { 0, 2, 3, 4, 5, 6, 7, 1, 8 }

124 };

125

126 #define MAX_ENTRIES 162

127

128 typedef struct MSS4Context {

129 AVFrame *pic;

130

131 VLC dc_vlc[2], ac_vlc[2];

132 VLC vec_entry_vlc[2];

133 int block[64];

134 uint8_t imgbuf[3][16 * 16];

135

136 int quality;

137 uint16_t quant_mat[2][64];

138

139 int *prev_dc[3];

140 int dc_stride[3];

141 int dc_cache[4][4];

142

143 int prev_vec[3][4];

144 } MSS4Context;

145

146 static av_cold int mss4_init_vlc(VLC *vlc, const uint8_t *lens,

147 const uint8_t *syms, int num_syms)

148 {

149 uint8_t bits[MAX_ENTRIES];

150 uint16_t codes[MAX_ENTRIES];

151 int i, j;

152 int prefix = 0, max_bits = 0, idx = 0;

153

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

155 for (j = 0; j < lens[i]; j++) {

156 bits[idx] = i + 1;

157 codes[idx] = prefix++;

158 max_bits = i + 1;

159 idx++;

160 }

161 prefix <<= 1;

162 }

163

164 return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,

165 codes, 2, 2, syms, 1, 1, 0);

166 }

167

168 static av_cold int mss4_init_vlcs(MSS4Context *ctx)

169 {

170 int ret, i;

171

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

173 ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);

174 if (ret)

175 return ret;

176 ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],

177 mss4_ac_vlc_syms[i], 162);

178 if (ret)

179 return ret;

180 ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],

181 mss4_vec_entry_vlc_syms[i], 9);

182 if (ret)

183 return ret;

184 }

185 return 0;

186 }

187

188 static av_cold void mss4_free_vlcs(MSS4Context *ctx)

189 {

190 int i;

191

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

193 ff_free_vlc(&ctx->dc_vlc[i]);

194 ff_free_vlc(&ctx->ac_vlc[i]);

195 ff_free_vlc(&ctx->vec_entry_vlc[i]);

196 }

197 }

198

199 /* This function returns values in the range

200 * (-range + 1; -range/2] U [range/2; range - 1)

201 * i.e.

202 * nbits = 0 -> 0

203 * nbits = 1 -> -1, 1

204 * nbits = 2 -> -3, -2, 2, 3

205 */

206 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)

207 {

208 int val;

209

210 if (!nbits)

211 return 0;

212

213 val = get_bits(gb, nbits);

214 if (val < (1 << (nbits - 1)))

215 val -= (1 << nbits) - 1;

216

217 return val;

218 }

219

220 static inline int get_coeff(GetBitContext *gb, VLC *vlc)

221 {

222 int val = get_vlc2(gb, vlc->table, vlc->bits, 2);

223

224 return get_coeff_bits(gb, val);

225 }

226

227 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,

228 int *block, int *dc_cache,

229 int bx, int by, uint16_t *quant_mat)

230 {

231 int skip, val, pos = 1, zz_pos, dc;

232

233 memset(block, 0, sizeof(*block) * 64);

234

235 dc = get_coeff(gb, dc_vlc);

236 // DC prediction is the same as in MSS3

237 if (by) {

238 if (bx) {

239 int l, tl, t;

240

241 l = dc_cache[LEFT];

242 tl = dc_cache[TOP_LEFT];

243 t = dc_cache[TOP];

244

245 if (FFABS(t - tl) <= FFABS(l - tl))

246 dc += l;

247 else

248 dc += t;

249 } else {

250 dc += dc_cache[TOP];

251 }

252 } else if (bx) {

253 dc += dc_cache[LEFT];

254 }

255 dc_cache[LEFT] = dc;

256 block[0] = dc * quant_mat[0];

257

258 while (pos < 64) {

259 val = get_vlc2(gb, ac_vlc->table, 9, 2);

260 if (!val)

261 return 0;

262 if (val == -1)

263 return -1;

264 if (val == 0xF0) {

265 pos += 16;

266 continue;

267 }

268 skip = val >> 4;

269 val = get_coeff_bits(gb, val & 0xF);

270 pos += skip;

271 if (pos >= 64)

272 return -1;

273

274 zz_pos = ff_zigzag_direct[pos];

275 block[zz_pos] = val * quant_mat[zz_pos];

276 pos++;

277 }

278

279 return pos == 64 ? 0 : -1;

280 }

281

282 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,

283 uint8_t *dst[3], int mb_x, int mb_y)

284 {

285 int i, j, k, ret;

286 uint8_t *out = dst[0];

287

288 for (j = 0; j < 2; j++) {

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

290 int xpos = mb_x * 2 + i;

291 c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];

292 c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];

293 ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,

294 c->dc_cache[j],

295 xpos, mb_y * 2 + j, c->quant_mat[0]);

296 if (ret)

297 return ret;

298 c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];

299

300 ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],

301 c->block);

302 }

303 out += 8 * c->pic->linesize[0];

304 }

305

306 for (i = 1; i < 3; i++) {

307 c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];

308 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];

309 ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,

310 c->block, c->dc_cache[i + 1], mb_x, mb_y,

311 c->quant_mat[1]);

312 if (ret)

313 return ret;

314 c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];

315

316 ff_mss34_dct_put(c->imgbuf[i], 8, c->block);

317 out = dst[i] + mb_x * 16;

318 // Since the DCT block is coded as YUV420 and the whole frame as YUV444,

319 // we need to scale chroma.

320 for (j = 0; j < 16; j++) {

321 for (k = 0; k < 8; k++)

322 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);

323 out += c->pic->linesize[i];

324 }

325 }

326

327 return 0;

328 }

329

330 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,

331 int *sel_len, int *prev)

332 {

333 int i, y_flag = 0;

334

335 for (i = 2; i >= 0; i--) {

336 if (!sel_flag[i]) {

337 vec_pos[i] = 0;

338 continue;

339 }

340 if ((!i && !y_flag) || get_bits1(gb)) {

341 if (sel_len[i] > 0) {

342 int pval = prev[i];

343 vec_pos[i] = get_bits(gb, sel_len[i]);

344 if (vec_pos[i] >= pval)

345 vec_pos[i]++;

346 } else {

347 vec_pos[i] = !prev[i];

348 }

349 y_flag = 1;

350 } else {

351 vec_pos[i] = prev[i];

352 }

353 }

354 }

355

356 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,

357 int vec_size, int component, int shift, int *prev)

358 {

359 if (vec_pos < vec_size)

360 return vec[vec_pos];

361 if (!get_bits1(gb))

362 return prev[component];

363 prev[component] = get_bits(gb, 8 - shift) << shift;

364 return prev[component];

365 }

366

367 #define MKVAL(vals) (vals[0] | (vals[1] << 3) | (vals[2] << 6))

368

369 /* Image mode - the hardest to comprehend MSS4 coding mode.

370 *

371 * In this mode all three 16x16 blocks are coded together with a method

372 * remotely similar to the methods employed in MSS1-MSS3.

373 * The idea is that every component has a vector of 1-4 most common symbols

374 * and an escape mode for reading new value from the bitstream. Decoding

375 * consists of retrieving pixel values from the vector or reading new ones

376 * from the bitstream; depending on flags read from the bitstream, these vector

377 * positions can be updated or reused from the state of the previous line

378 * or previous pixel.

379 */

380 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,

381 uint8_t *picdst[3], int mb_x, int mb_y)

382 {

383 uint8_t vec[3][4];

384 int vec_len[3];

385 int sel_len[3], sel_flag[3];

386 int i, j, k, mode, split;

387 int prev_vec1 = 0, prev_split = 0;

388 int vals[3] = { 0 };

389 int prev_pix[3] = { 0 };

390 int prev_mode[16] = { 0 };

391 uint8_t *dst[3];

392

393 const int val_shift = ctx->quality == 100 ? 0 : 2;

394

395 for (i = 0; i < 3; i++)

396 dst[i] = ctx->imgbuf[i];

397

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

399 vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];

400 for (j = 0; j < vec_len[i]; j++) {

401 vec[i][j] = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);

402 vec[i][j] += ctx->prev_vec[i][j];

403 ctx->prev_vec[i][j] = vec[i][j];

404 }

405 sel_flag[i] = vec_len[i] > 1;

406 sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;

407 }

408

409 for (j = 0; j < 16; j++) {

410 if (get_bits1(gb)) {

411 split = 0;

412 if (get_bits1(gb)) {

413 prev_mode[0] = 0;

414 vals[0] = vals[1] = vals[2] = 0;

415 mode = 2;

416 } else {

417 mode = get_bits1(gb);

418 if (mode)

419 split = get_bits(gb, 4);

420 }

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

422 if (mode <= 1) {

423 vals[0] = prev_mode[i] & 7;

424 vals[1] = (prev_mode[i] >> 3) & 7;

425 vals[2] = prev_mode[i] >> 6;

426 if (mode == 1 && i == split) {

427 read_vec_pos(gb, vals, sel_flag, sel_len, vals);

428 }

429 } else if (mode == 2) {

430 if (get_bits1(gb))

431 read_vec_pos(gb, vals, sel_flag, sel_len, vals);

432 }

433 for (k = 0; k < 3; k++)

434 *dst[k]++ = get_value_cached(gb, vals[k], vec[k],

435 vec_len[k], k,

436 val_shift, prev_pix);

437 prev_mode[i] = MKVAL(vals);

438 }

439 } else {

440 if (get_bits1(gb)) {

441 split = get_bits(gb, 4);

442 if (split >= prev_split)

443 split++;

444 prev_split = split;

445 } else {

446 split = prev_split;

447 }

448 if (split) {

449 vals[0] = prev_mode[0] & 7;

450 vals[1] = (prev_mode[0] >> 3) & 7;

451 vals[2] = prev_mode[0] >> 6;

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

453 for (k = 0; k < split; k++) {

454 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],

455 vec_len[i], i, val_shift,

456 prev_pix);

457 prev_mode[k] = MKVAL(vals);

458 }

459 }

460 }

461

462 if (split != 16) {

463 vals[0] = prev_vec1 & 7;

464 vals[1] = (prev_vec1 >> 3) & 7;

465 vals[2] = prev_vec1 >> 6;

466 if (get_bits1(gb)) {

467 read_vec_pos(gb, vals, sel_flag, sel_len, vals);

468 prev_vec1 = MKVAL(vals);

469 }

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

471 for (k = 0; k < 16 - split; k++) {

472 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],

473 vec_len[i], i, val_shift,

474 prev_pix);

475 prev_mode[split + k] = MKVAL(vals);

476 }

477 }

478 }

479 }

480 }

481

482 for (i = 0; i < 3; i++)

483 for (j = 0; j < 16; j++)

484 memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],

485 ctx->imgbuf[i] + j * 16, 16);

486

487 return 0;

488 }

489

490 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)

491 {

492 int i;

493

494 c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];

495 c->dc_cache[0][LEFT] = 0;

496 c->dc_cache[1][TOP] = 0;

497 c->dc_cache[1][LEFT] = 0;

498

499 for (i = 0; i < 2; i++)

500 c->prev_dc[0][mb_x * 2 + i] = 0;

501

502 for (i = 1; i < 3; i++) {

503 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];

504 c->dc_cache[i + 1][LEFT] = 0;

505 c->prev_dc[i][mb_x] = 0;

506 }

507 }

508

509 static int mss4_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

510 AVPacket *avpkt)

511 {

512 const uint8_t *buf = avpkt->data;

513 int buf_size = avpkt->size;

514 MSS4Context *c = avctx->priv_data;

515 GetBitContext gb;

516 GetByteContext bc;

517 uint8_t *dst[3];

518 int width, height, quality, frame_type;

519 int x, y, i, mb_width, mb_height, blk_type;

520 int ret;

521

522 if (buf_size < HEADER_SIZE) {

523 av_log(avctx, AV_LOG_ERROR,

524 "Frame should have at least %d bytes, got %d instead\n",

525 HEADER_SIZE, buf_size);

526 return AVERROR_INVALIDDATA;

527 }

528

529 bytestream2_init(&bc, buf, buf_size);

530 width = bytestream2_get_be16(&bc);

531 height = bytestream2_get_be16(&bc);

532 bytestream2_skip(&bc, 2);

533 quality = bytestream2_get_byte(&bc);

534 frame_type = bytestream2_get_byte(&bc);

535

536 if (width > avctx->width ||

537 height != avctx->height) {

538 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",

539 width, height);

540 return AVERROR_INVALIDDATA;

541 }

542 if (quality < 1 || quality > 100) {

543 av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);

544 return AVERROR_INVALIDDATA;

545 }

546 if ((frame_type & ~3) || frame_type == 3) {

547 av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);

548 return AVERROR_INVALIDDATA;

549 }

550

551 if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {

552 av_log(avctx, AV_LOG_ERROR,

553 "Empty frame found but it is not a skip frame.\n");

554 return AVERROR_INVALIDDATA;

555 }

556

557 if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)

558 return ret;

559 c->pic->key_frame = (frame_type == INTRA_FRAME);

560 c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I

561 : AV_PICTURE_TYPE_P;

562 if (frame_type == SKIP_FRAME) {

563 *got_frame = 1;

564 if ((ret = av_frame_ref(data, c->pic)) < 0)

565 return ret;

566

567 return buf_size;

568 }

569

570 if (c->quality != quality) {

571 c->quality = quality;

572 for (i = 0; i < 2; i++)

573 ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);

574 }

575

576 init_get_bits8(&gb, buf + HEADER_SIZE, (buf_size - HEADER_SIZE));

577

578 mb_width = FFALIGN(width, 16) >> 4;

579 mb_height = FFALIGN(height, 16) >> 4;

580 dst[0] = c->pic->data[0];

581 dst[1] = c->pic->data[1];

582 dst[2] = c->pic->data[2];

583

584 memset(c->prev_vec, 0, sizeof(c->prev_vec));

585 for (y = 0; y < mb_height; y++) {

586 memset(c->dc_cache, 0, sizeof(c->dc_cache));

587 for (x = 0; x < mb_width; x++) {

588 blk_type = decode012(&gb);

589 switch (blk_type) {

590 case DCT_BLOCK:

591 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {

592 av_log(avctx, AV_LOG_ERROR,

593 "Error decoding DCT block %d,%d\n",

594 x, y);

595 return AVERROR_INVALIDDATA;

596 }

597 break;

598 case IMAGE_BLOCK:

599 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {

600 av_log(avctx, AV_LOG_ERROR,

601 "Error decoding VQ block %d,%d\n",

602 x, y);

603 return AVERROR_INVALIDDATA;

604 }

605 break;

606 case SKIP_BLOCK:

607 if (frame_type == INTRA_FRAME) {

608 av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");

609 return AVERROR_INVALIDDATA;

610 }

611 break;

612 }

613 if (blk_type != DCT_BLOCK)

614 mss4_update_dc_cache(c, x);

615 }

616 dst[0] += c->pic->linesize[0] * 16;

617 dst[1] += c->pic->linesize[1] * 16;

618 dst[2] += c->pic->linesize[2] * 16;

619 }

620

621 if ((ret = av_frame_ref(data, c->pic)) < 0)

622 return ret;

623

624 *got_frame = 1;

625

626 return buf_size;

627 }

628

629 static av_cold int mss4_decode_init(AVCodecContext *avctx)

630 {

631 MSS4Context * const c = avctx->priv_data;

632 int i;

633

634 c->pic = av_frame_alloc();

635 if (!c->pic)

636 return AVERROR(ENOMEM);

637

638 if (mss4_init_vlcs(c)) {

639 av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");

640 mss4_free_vlcs(c);

641 return AVERROR(ENOMEM);

642 }

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

644 c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);

645 c->prev_dc[i] = av_malloc(sizeof(**c->prev_dc) * c->dc_stride[i]);

646 if (!c->prev_dc[i]) {

647 av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");

648 mss4_free_vlcs(c);

649 return AVERROR(ENOMEM);

650 }

651 }

652

653 avctx->pix_fmt = AV_PIX_FMT_YUV444P;

654

655 return 0;

656 }

657

658 static av_cold int mss4_decode_end(AVCodecContext *avctx)

659 {

660 MSS4Context * const c = avctx->priv_data;

661 int i;

662

663 av_frame_free(&c->pic);

664

665 for (i = 0; i < 3; i++)

666 av_freep(&c->prev_dc[i]);

667 mss4_free_vlcs(c);

668

669 return 0;

670 }

671

672 AVCodec ff_mts2_decoder = {

673 .name = "mts2",

674 .type = AVMEDIA_TYPE_VIDEO,

675 .id = AV_CODEC_ID_MTS2,

676 .priv_data_size = sizeof(MSS4Context),

677 .init = mss4_decode_init,

678 .close = mss4_decode_end,

679 .decode = mss4_decode_frame,

680 .capabilities = CODEC_CAP_DR1,

681 .long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),

682 };

Generated on Wed Jul 10 2013 23:48:02 for FFmpeg by doxygen 1.8.2