FFmpeg: libavcodec/dfa.c Source File

FFmpeg

[フレーム]

libavcodec

dfa.c

Go to the documentation of this file.

1 /*

2 * Chronomaster DFA Video Decoder

4 * based on work by Vladimir "VAG" Gneushev

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 #include "libavutil/avassert.h"

24 #include "avcodec.h"

25 #include "bytestream.h"

26 #include "internal.h"

28 #include "libavutil/imgutils.h"

29 #include "libavutil/mem.h"

31 typedef struct DfaContext {

32 uint32_t pal[256];

33 uint8_t *frame_buf;

34 } DfaContext;

36 static av_cold int dfa_decode_init(AVCodecContext *avctx)

37 {

38 DfaContext *s = avctx->priv_data;

40 avctx->pix_fmt = AV_PIX_FMT_PAL8;

42 if (!avctx->width || !avctx->height)

43 return AVERROR_INVALIDDATA;

45 av_assert0(av_image_check_size(avctx->width, avctx->height, 0, avctx) >= 0);

47 s->frame_buf = av_mallocz(avctx->width * avctx->height);

48 if (!s->frame_buf)

49 return AVERROR(ENOMEM);

51 return 0;

52 }

54 static int decode_copy(GetByteContext *gb, uint8_t *frame, int width, int height)

55 {

56 const int size = width * height;

58 if (bytestream2_get_buffer(gb, frame, size) != size)

59 return AVERROR_INVALIDDATA;

60 return 0;

61 }

63 static int decode_tsw1(GetByteContext *gb, uint8_t *frame, int width, int height)

64 {

65 const uint8_t *frame_start = frame;

66 const uint8_t *frame_end = frame + width * height;

67 int mask = 0x10000, bitbuf = 0;

68 int v, count, segments;

69 unsigned offset;

71 segments = bytestream2_get_le32(gb);

72 offset = bytestream2_get_le32(gb);

73 if (segments == 0 && offset == frame_end - frame)

74 return 0; // skip frame

75 if (frame_end - frame <= offset)

76 return AVERROR_INVALIDDATA;

77 frame += offset;

78 while (segments--) {

79 if (bytestream2_get_bytes_left(gb) < 2)

80 return AVERROR_INVALIDDATA;

81 if (mask == 0x10000) {

82 bitbuf = bytestream2_get_le16u(gb);

83 mask = 1;

84 }

85 if (frame_end - frame < 2)

86 return AVERROR_INVALIDDATA;

87 if (bitbuf & mask) {

88 v = bytestream2_get_le16(gb);

89 offset = (v & 0x1FFF) << 1;

90 count = ((v >> 13) + 2) << 1;

91 if (frame - frame_start < offset || frame_end - frame < count)

92 return AVERROR_INVALIDDATA;

93 av_memcpy_backptr(frame, offset, count);

94 frame += count;

95 } else {

96 *frame++ = bytestream2_get_byte(gb);

97 *frame++ = bytestream2_get_byte(gb);

98 }

99 mask <<= 1;

100 }

101

102 return 0;

103 }

104

105 static int decode_dsw1(GetByteContext *gb, uint8_t *frame, int width, int height)

106 {

107 const uint8_t *frame_start = frame;

108 const uint8_t *frame_end = frame + width * height;

109 int mask = 0x10000, bitbuf = 0;

110 int v, offset, count, segments;

111

112 segments = bytestream2_get_le16(gb);

113 while (segments--) {

114 if (bytestream2_get_bytes_left(gb) < 2)

115 return AVERROR_INVALIDDATA;

116 if (mask == 0x10000) {

117 bitbuf = bytestream2_get_le16u(gb);

118 mask = 1;

119 }

120 if (frame_end - frame < 2)

121 return AVERROR_INVALIDDATA;

122 if (bitbuf & mask) {

123 v = bytestream2_get_le16(gb);

124 offset = (v & 0x1FFF) << 1;

125 count = ((v >> 13) + 2) << 1;

126 if (frame - frame_start < offset || frame_end - frame < count)

127 return AVERROR_INVALIDDATA;

128 av_memcpy_backptr(frame, offset, count);

129 frame += count;

130 } else if (bitbuf & (mask << 1)) {

131 frame += bytestream2_get_le16(gb);

132 } else {

133 *frame++ = bytestream2_get_byte(gb);

134 *frame++ = bytestream2_get_byte(gb);

135 }

136 mask <<= 2;

137 }

138

139 return 0;

140 }

141

142 static int decode_dds1(GetByteContext *gb, uint8_t *frame, int width, int height)

143 {

144 const uint8_t *frame_start = frame;

145 const uint8_t *frame_end = frame + width * height;

146 int mask = 0x10000, bitbuf = 0;

147 int i, v, offset, count, segments;

148

149 segments = bytestream2_get_le16(gb);

150 while (segments--) {

151 if (bytestream2_get_bytes_left(gb) < 2)

152 return AVERROR_INVALIDDATA;

153 if (mask == 0x10000) {

154 bitbuf = bytestream2_get_le16u(gb);

155 mask = 1;

156 }

157

158 if (bitbuf & mask) {

159 v = bytestream2_get_le16(gb);

160 offset = (v & 0x1FFF) << 2;

161 count = ((v >> 13) + 2) << 1;

162 if (frame - frame_start < offset || frame_end - frame < count*2 + width)

163 return AVERROR_INVALIDDATA;

164 for (i = 0; i < count; i++) {

165 frame[0] = frame[1] =

166 frame[width] = frame[width + 1] = frame[-offset];

167

168 frame += 2;

169 }

170 } else if (bitbuf & (mask << 1)) {

171 v = bytestream2_get_le16(gb)*2;

172 if (frame - frame_end < v)

173 return AVERROR_INVALIDDATA;

174 frame += v;

175 } else {

176 if (frame_end - frame < width + 3)

177 return AVERROR_INVALIDDATA;

178 frame[0] = frame[1] =

179 frame[width] = frame[width + 1] = bytestream2_get_byte(gb);

180 frame += 2;

181 frame[0] = frame[1] =

182 frame[width] = frame[width + 1] = bytestream2_get_byte(gb);

183 frame += 2;

184 }

185 mask <<= 2;

186 }

187

188 return 0;

189 }

190

191 static int decode_bdlt(GetByteContext *gb, uint8_t *frame, int width, int height)

192 {

193 uint8_t *line_ptr;

194 int count, lines, segments;

195

196 count = bytestream2_get_le16(gb);

197 if (count >= height)

198 return AVERROR_INVALIDDATA;

199 frame += width * count;

200 lines = bytestream2_get_le16(gb);

201 if (count + lines > height)

202 return AVERROR_INVALIDDATA;

203

204 while (lines--) {

205 if (bytestream2_get_bytes_left(gb) < 1)

206 return AVERROR_INVALIDDATA;

207 line_ptr = frame;

208 frame += width;

209 segments = bytestream2_get_byteu(gb);

210 while (segments--) {

211 if (frame - line_ptr <= bytestream2_peek_byte(gb))

212 return AVERROR_INVALIDDATA;

213 line_ptr += bytestream2_get_byte(gb);

214 count = (int8_t)bytestream2_get_byte(gb);

215 if (count >= 0) {

216 if (frame - line_ptr < count)

217 return AVERROR_INVALIDDATA;

218 if (bytestream2_get_buffer(gb, line_ptr, count) != count)

219 return AVERROR_INVALIDDATA;

220 } else {

221 count = -count;

222 if (frame - line_ptr < count)

223 return AVERROR_INVALIDDATA;

224 memset(line_ptr, bytestream2_get_byte(gb), count);

225 }

226 line_ptr += count;

227 }

228 }

229

230 return 0;

231 }

232

233 static int decode_wdlt(GetByteContext *gb, uint8_t *frame, int width, int height)

234 {

235 const uint8_t *frame_end = frame + width * height;

236 uint8_t *line_ptr;

237 int count, i, v, lines, segments;

238 int y = 0;

239

240 lines = bytestream2_get_le16(gb);

241 if (lines > height)

242 return AVERROR_INVALIDDATA;

243

244 while (lines--) {

245 if (bytestream2_get_bytes_left(gb) < 2)

246 return AVERROR_INVALIDDATA;

247 segments = bytestream2_get_le16u(gb);

248 while ((segments & 0xC000) == 0xC000) {

249 unsigned skip_lines = -(int16_t)segments;

250 unsigned delta = -((int16_t)segments * width);

251 if (frame_end - frame <= delta || y + lines + skip_lines > height)

252 return AVERROR_INVALIDDATA;

253 frame += delta;

254 y += skip_lines;

255 segments = bytestream2_get_le16(gb);

256 }

257

258 if (frame_end <= frame)

259 return AVERROR_INVALIDDATA;

260 if (segments & 0x8000) {

261 frame[width - 1] = segments & 0xFF;

262 segments = bytestream2_get_le16(gb);

263 }

264 line_ptr = frame;

265 if (frame_end - frame < width)

266 return AVERROR_INVALIDDATA;

267 frame += width;

268 y++;

269 while (segments--) {

270 if (frame - line_ptr <= bytestream2_peek_byte(gb))

271 return AVERROR_INVALIDDATA;

272 line_ptr += bytestream2_get_byte(gb);

273 count = (int8_t)bytestream2_get_byte(gb);

274 if (count >= 0) {

275 if (frame - line_ptr < count * 2)

276 return AVERROR_INVALIDDATA;

277 if (bytestream2_get_buffer(gb, line_ptr, count * 2) != count * 2)

278 return AVERROR_INVALIDDATA;

279 line_ptr += count * 2;

280 } else {

281 count = -count;

282 if (frame - line_ptr < count * 2)

283 return AVERROR_INVALIDDATA;

284 v = bytestream2_get_le16(gb);

285 for (i = 0; i < count; i++)

286 bytestream_put_le16(&line_ptr, v);

287 }

288 }

289 }

290

291 return 0;

292 }

293

294 static int decode_tdlt(GetByteContext *gb, uint8_t *frame, int width, int height)

295 {

296 const uint8_t *frame_end = frame + width * height;

297 uint32_t segments = bytestream2_get_le32(gb);

298 int skip, copy;

299

300 while (segments--) {

301 if (bytestream2_get_bytes_left(gb) < 2)

302 return AVERROR_INVALIDDATA;

303 copy = bytestream2_get_byteu(gb) * 2;

304 skip = bytestream2_get_byteu(gb) * 2;

305 if (frame_end - frame < copy + skip ||

306 bytestream2_get_bytes_left(gb) < copy)

307 return AVERROR_INVALIDDATA;

308 frame += skip;

309 bytestream2_get_buffer(gb, frame, copy);

310 frame += copy;

311 }

312

313 return 0;

314 }

315

316 static int decode_blck(GetByteContext *gb, uint8_t *frame, int width, int height)

317 {

318 memset(frame, 0, width * height);

319 return 0;

320 }

321

322

323 typedef int (*chunk_decoder)(GetByteContext *gb, uint8_t *frame, int width, int height);

324

325 static const chunk_decoder decoder[8] = {

326 decode_copy, decode_tsw1, decode_bdlt, decode_wdlt,

327 decode_tdlt, decode_dsw1, decode_blck, decode_dds1,

328 };

329

330 static const char* chunk_name[8] = {

331 "COPY", "TSW1", "BDLT", "WDLT", "TDLT", "DSW1", "BLCK", "DDS1"

332 };

333

334 static int dfa_decode_frame(AVCodecContext *avctx,

335 void *data, int *got_frame,

336 AVPacket *avpkt)

337 {

338 AVFrame *frame = data;

339 DfaContext *s = avctx->priv_data;

340 GetByteContext gb;

341 const uint8_t *buf = avpkt->data;

342 uint32_t chunk_type, chunk_size;

343 uint8_t *dst;

344 int ret;

345 int i, pal_elems;

346 int version = avctx->extradata_size==2 ? AV_RL16(avctx->extradata) : 0;

347

348 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

349 return ret;

350

351 bytestream2_init(&gb, avpkt->data, avpkt->size);

352 while (bytestream2_get_bytes_left(&gb) > 0) {

353 bytestream2_skip(&gb, 4);

354 chunk_size = bytestream2_get_le32(&gb);

355 chunk_type = bytestream2_get_le32(&gb);

356 if (!chunk_type)

357 break;

358 if (chunk_type == 1) {

359 pal_elems = FFMIN(chunk_size / 3, 256);

360 for (i = 0; i < pal_elems; i++) {

361 s->pal[i] = bytestream2_get_be24(&gb) << 2;

362 s->pal[i] |= 0xFFU << 24 | (s->pal[i] >> 6) & 0x30303;

363 }

364 frame->palette_has_changed = 1;

365 } else if (chunk_type <= 9) {

366 if (decoder[chunk_type - 2](&gb, s->frame_buf, avctx->width, avctx->height)) {

367 av_log(avctx, AV_LOG_ERROR, "Error decoding %s chunk\n",

368 chunk_name[chunk_type - 2]);

369 return AVERROR_INVALIDDATA;

370 }

371 } else {

372 av_log(avctx, AV_LOG_WARNING, "Ignoring unknown chunk type %d\n",

373 chunk_type);

374 }

375 buf += chunk_size;

376 }

377

378 buf = s->frame_buf;

379 dst = frame->data[0];

380 for (i = 0; i < avctx->height; i++) {

381 if(version == 0x100) {

382 int j;

383 for(j = 0; j < avctx->width; j++) {

384 dst[j] = buf[ (i&3)*(avctx->width /4) + (j/4) +

385 ((j&3)*(avctx->height/4) + (i/4))*avctx->width];

386 }

387 } else {

388 memcpy(dst, buf, avctx->width);

389 buf += avctx->width;

390 }

391 dst += frame->linesize[0];

392 }

393 memcpy(frame->data[1], s->pal, sizeof(s->pal));

394

395 *got_frame = 1;

396

397 return avpkt->size;

398 }

399

400 static av_cold int dfa_decode_end(AVCodecContext *avctx)

401 {

402 DfaContext *s = avctx->priv_data;

403

404 av_freep(&s->frame_buf);

405

406 return 0;

407 }

408

409 AVCodec ff_dfa_decoder = {

410 .name = "dfa",

411 .type = AVMEDIA_TYPE_VIDEO,

412 .id = AV_CODEC_ID_DFA,

413 .priv_data_size = sizeof(DfaContext),

414 .init = dfa_decode_init,

415 .close = dfa_decode_end,

416 .decode = dfa_decode_frame,

417 .capabilities = CODEC_CAP_DR1,

418 .long_name = NULL_IF_CONFIG_SMALL("Chronomaster DFA"),

419 };

Generated on Wed Jul 10 2013 23:47:56 for FFmpeg by doxygen 1.8.2