FFmpeg: libavcodec/cdgraphics.c Source File

FFmpeg

[フレーム]

libavcodec

cdgraphics.c

Go to the documentation of this file.

1 /*

2 * CD Graphics Video 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 #include "avcodec.h"

23 #include "bytestream.h"

24 #include "internal.h"

26 /**

27 * @file

28 * @brief CD Graphics Video Decoder

29 * @author Michael Tison

30 * @see http://wiki.multimedia.cx/index.php?title=CD_Graphics

31 * @see http://www.ccs.neu.edu/home/bchafy/cdb/info/cdg

32 */

34 /// default screen sizes

35 #define CDG_FULL_WIDTH 300

36 #define CDG_FULL_HEIGHT 216

37 #define CDG_DISPLAY_WIDTH 294

38 #define CDG_DISPLAY_HEIGHT 204

39 #define CDG_BORDER_WIDTH 6

40 #define CDG_BORDER_HEIGHT 12

42 /// masks

43 #define CDG_COMMAND 0x09

44 #define CDG_MASK 0x3F

46 /// instruction codes

47 #define CDG_INST_MEMORY_PRESET 1

48 #define CDG_INST_BORDER_PRESET 2

49 #define CDG_INST_TILE_BLOCK 6

50 #define CDG_INST_SCROLL_PRESET 20

51 #define CDG_INST_SCROLL_COPY 24

52 #define CDG_INST_LOAD_PAL_LO 30

53 #define CDG_INST_LOAD_PAL_HIGH 31

54 #define CDG_INST_TILE_BLOCK_XOR 38

56 /// data sizes

57 #define CDG_PACKET_SIZE 24

58 #define CDG_DATA_SIZE 16

59 #define CDG_TILE_HEIGHT 12

60 #define CDG_TILE_WIDTH 6

61 #define CDG_MINIMUM_PKT_SIZE 6

62 #define CDG_MINIMUM_SCROLL_SIZE 3

63 #define CDG_HEADER_SIZE 8

64 #define CDG_PALETTE_SIZE 16

66 typedef struct CDGraphicsContext {

67 AVFrame frame;

68 int hscroll;

69 int vscroll;

70 } CDGraphicsContext;

72 static void cdg_init_frame(AVFrame *frame)

73 {

74 avcodec_get_frame_defaults(frame);

75 frame->reference = 3;

76 frame->buffer_hints = FF_BUFFER_HINTS_VALID |

77 FF_BUFFER_HINTS_READABLE |

78 FF_BUFFER_HINTS_PRESERVE |

79 FF_BUFFER_HINTS_REUSABLE;

80 }

82 static av_cold int cdg_decode_init(AVCodecContext *avctx)

83 {

84 CDGraphicsContext *cc = avctx->priv_data;

86 cdg_init_frame(&cc->frame);

88 avctx->width = CDG_FULL_WIDTH;

89 avctx->height = CDG_FULL_HEIGHT;

90 avctx->pix_fmt = AV_PIX_FMT_PAL8;

92 return 0;

93 }

95 static void cdg_border_preset(CDGraphicsContext *cc, uint8_t *data)

96 {

97 int y;

98 int lsize = cc->frame.linesize[0];

99 uint8_t *buf = cc->frame.data[0];

100 int color = data[0] & 0x0F;

101

102 if (!(data[1] & 0x0F)) {

103 /// fill the top and bottom borders

104 memset(buf, color, CDG_BORDER_HEIGHT * lsize);

105 memset(buf + (CDG_FULL_HEIGHT - CDG_BORDER_HEIGHT) * lsize,

106 color, CDG_BORDER_HEIGHT * lsize);

107

108 /// fill the side borders

109 for (y = CDG_BORDER_HEIGHT; y < CDG_FULL_HEIGHT - CDG_BORDER_HEIGHT; y++) {

110 memset(buf + y * lsize, color, CDG_BORDER_WIDTH);

111 memset(buf + CDG_FULL_WIDTH - CDG_BORDER_WIDTH + y * lsize,

112 color, CDG_BORDER_WIDTH);

113 }

114 }

115 }

116

117 static void cdg_load_palette(CDGraphicsContext *cc, uint8_t *data, int low)

118 {

119 uint8_t r, g, b;

120 uint16_t color;

121 int i;

122 int array_offset = low ? 0 : 8;

123 uint32_t *palette = (uint32_t *) cc->frame.data[1];

124

125 for (i = 0; i < 8; i++) {

126 color = (data[2 * i] << 6) + (data[2 * i + 1] & 0x3F);

127 r = ((color >> 8) & 0x000F) * 17;

128 g = ((color >> 4) & 0x000F) * 17;

129 b = ((color ) & 0x000F) * 17;

130 palette[i + array_offset] = 0xFFU << 24 | r << 16 | g << 8 | b;

131 }

132 cc->frame.palette_has_changed = 1;

133 }

134

135 static int cdg_tile_block(CDGraphicsContext *cc, uint8_t *data, int b)

136 {

137 unsigned ci, ri;

138 int color;

139 int x, y;

140 int ai;

141 int stride = cc->frame.linesize[0];

142 uint8_t *buf = cc->frame.data[0];

143

144 ri = (data[2] & 0x1F) * CDG_TILE_HEIGHT + cc->vscroll;

145 ci = (data[3] & 0x3F) * CDG_TILE_WIDTH + cc->hscroll;

146

147 if (ri > (CDG_FULL_HEIGHT - CDG_TILE_HEIGHT))

148 return AVERROR(EINVAL);

149 if (ci > (CDG_FULL_WIDTH - CDG_TILE_WIDTH))

150 return AVERROR(EINVAL);

151

152 for (y = 0; y < CDG_TILE_HEIGHT; y++) {

153 for (x = 0; x < CDG_TILE_WIDTH; x++) {

154 if (!((data[4 + y] >> (5 - x)) & 0x01))

155 color = data[0] & 0x0F;

156 else

157 color = data[1] & 0x0F;

158

159 ai = ci + x + (stride * (ri + y));

160 if (b)

161 color ^= buf[ai];

162 buf[ai] = color;

163 }

164 }

165

166 return 0;

167 }

168

169 #define UP 2

170 #define DOWN 1

171 #define LEFT 2

172 #define RIGHT 1

173

174 static void cdg_copy_rect_buf(int out_tl_x, int out_tl_y, uint8_t *out,

175 int in_tl_x, int in_tl_y, uint8_t *in,

176 int w, int h, int stride)

177 {

178 int y;

179

180 in += in_tl_x + in_tl_y * stride;

181 out += out_tl_x + out_tl_y * stride;

182 for (y = 0; y < h; y++)

183 memcpy(out + y * stride, in + y * stride, w);

184 }

185

186 static void cdg_fill_rect_preset(int tl_x, int tl_y, uint8_t *out,

187 int color, int w, int h, int stride)

188 {

189 int y;

190

191 for (y = tl_y; y < tl_y + h; y++)

192 memset(out + tl_x + y * stride, color, w);

193 }

194

195 static void cdg_fill_wrapper(int out_tl_x, int out_tl_y, uint8_t *out,

196 int in_tl_x, int in_tl_y, uint8_t *in,

197 int color, int w, int h, int stride, int roll)

198 {

199 if (roll) {

200 cdg_copy_rect_buf(out_tl_x, out_tl_y, out, in_tl_x, in_tl_y,

201 in, w, h, stride);

202 } else {

203 cdg_fill_rect_preset(out_tl_x, out_tl_y, out, color, w, h, stride);

204 }

205 }

206

207 static void cdg_scroll(CDGraphicsContext *cc, uint8_t *data,

208 AVFrame *new_frame, int roll_over)

209 {

210 int color;

211 int hscmd, h_off, hinc, vscmd, v_off, vinc;

212 int y;

213 int stride = cc->frame.linesize[0];

214 uint8_t *in = cc->frame.data[0];

215 uint8_t *out = new_frame->data[0];

216

217 color = data[0] & 0x0F;

218 hscmd = (data[1] & 0x30) >> 4;

219 vscmd = (data[2] & 0x30) >> 4;

220

221 h_off = FFMIN(data[1] & 0x07, CDG_BORDER_WIDTH - 1);

222 v_off = FFMIN(data[2] & 0x0F, CDG_BORDER_HEIGHT - 1);

223

224 /// find the difference and save the offset for cdg_tile_block usage

225 hinc = h_off - cc->hscroll;

226 vinc = v_off - cc->vscroll;

227 cc->hscroll = h_off;

228 cc->vscroll = v_off;

229

230 if (vscmd == UP)

231 vinc -= 12;

232 if (vscmd == DOWN)

233 vinc += 12;

234 if (hscmd == LEFT)

235 hinc -= 6;

236 if (hscmd == RIGHT)

237 hinc += 6;

238

239 if (!hinc && !vinc)

240 return;

241

242 memcpy(new_frame->data[1], cc->frame.data[1], CDG_PALETTE_SIZE * 4);

243

244 for (y = FFMAX(0, vinc); y < FFMIN(CDG_FULL_HEIGHT + vinc, CDG_FULL_HEIGHT); y++)

245 memcpy(out + FFMAX(0, hinc) + stride * y,

246 in + FFMAX(0, hinc) - hinc + (y - vinc) * stride,

247 FFMIN(stride + hinc, stride));

248

249 if (vinc > 0)

250 cdg_fill_wrapper(0, 0, out,

251 0, CDG_FULL_HEIGHT - vinc, in, color,

252 stride, vinc, stride, roll_over);

253 else if (vinc < 0)

254 cdg_fill_wrapper(0, CDG_FULL_HEIGHT + vinc, out,

255 0, 0, in, color,

256 stride, -1 * vinc, stride, roll_over);

257

258 if (hinc > 0)

259 cdg_fill_wrapper(0, 0, out,

260 CDG_FULL_WIDTH - hinc, 0, in, color,

261 hinc, CDG_FULL_HEIGHT, stride, roll_over);

262 else if (hinc < 0)

263 cdg_fill_wrapper(CDG_FULL_WIDTH + hinc, 0, out,

264 0, 0, in, color,

265 -1 * hinc, CDG_FULL_HEIGHT, stride, roll_over);

266

267 }

268

269 static int cdg_decode_frame(AVCodecContext *avctx,

270 void *data, int *got_frame, AVPacket *avpkt)

271 {

272 const uint8_t *buf = avpkt->data;

273 int buf_size = avpkt->size;

274 int ret;

275 uint8_t command, inst;

276 uint8_t cdg_data[CDG_DATA_SIZE];

277 AVFrame new_frame;

278 CDGraphicsContext *cc = avctx->priv_data;

279

280 if (buf_size < CDG_MINIMUM_PKT_SIZE) {

281 av_log(avctx, AV_LOG_ERROR, "buffer too small for decoder\n");

282 return AVERROR(EINVAL);

283 }

284 if (buf_size > CDG_HEADER_SIZE + CDG_DATA_SIZE) {

285 av_log(avctx, AV_LOG_ERROR, "buffer too big for decoder\n");

286 return AVERROR(EINVAL);

287 }

288

289 ret = avctx->reget_buffer(avctx, &cc->frame);

290 if (ret) {

291 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");

292 return ret;

293 }

294

295 command = bytestream_get_byte(&buf);

296 inst = bytestream_get_byte(&buf);

297 inst &= CDG_MASK;

298 buf += 2; /// skipping 2 unneeded bytes

299

300 if (buf_size > CDG_HEADER_SIZE)

301 bytestream_get_buffer(&buf, cdg_data, buf_size - CDG_HEADER_SIZE);

302

303 if ((command & CDG_MASK) == CDG_COMMAND) {

304 switch (inst) {

305 case CDG_INST_MEMORY_PRESET:

306 if (!(cdg_data[1] & 0x0F))

307 memset(cc->frame.data[0], cdg_data[0] & 0x0F,

308 cc->frame.linesize[0] * CDG_FULL_HEIGHT);

309 break;

310 case CDG_INST_LOAD_PAL_LO:

311 case CDG_INST_LOAD_PAL_HIGH:

312 if (buf_size - CDG_HEADER_SIZE < CDG_DATA_SIZE) {

313 av_log(avctx, AV_LOG_ERROR, "buffer too small for loading palette\n");

314 return AVERROR(EINVAL);

315 }

316

317 cdg_load_palette(cc, cdg_data, inst == CDG_INST_LOAD_PAL_LO);

318 break;

319 case CDG_INST_BORDER_PRESET:

320 cdg_border_preset(cc, cdg_data);

321 break;

322 case CDG_INST_TILE_BLOCK_XOR:

323 case CDG_INST_TILE_BLOCK:

324 if (buf_size - CDG_HEADER_SIZE < CDG_DATA_SIZE) {

325 av_log(avctx, AV_LOG_ERROR, "buffer too small for drawing tile\n");

326 return AVERROR(EINVAL);

327 }

328

329 ret = cdg_tile_block(cc, cdg_data, inst == CDG_INST_TILE_BLOCK_XOR);

330 if (ret) {

331 av_log(avctx, AV_LOG_ERROR, "tile is out of range\n");

332 return ret;

333 }

334 break;

335 case CDG_INST_SCROLL_PRESET:

336 case CDG_INST_SCROLL_COPY:

337 if (buf_size - CDG_HEADER_SIZE < CDG_MINIMUM_SCROLL_SIZE) {

338 av_log(avctx, AV_LOG_ERROR, "buffer too small for scrolling\n");

339 return AVERROR(EINVAL);

340 }

341

342 cdg_init_frame(&new_frame);

343 ret = ff_get_buffer(avctx, &new_frame);

344 if (ret) {

345 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

346 return ret;

347 }

348

349 cdg_scroll(cc, cdg_data, &new_frame, inst == CDG_INST_SCROLL_COPY);

350 avctx->release_buffer(avctx, &cc->frame);

351 cc->frame = new_frame;

352 break;

353 default:

354 break;

355 }

356

357 *got_frame = 1;

358 } else {

359 *got_frame = 0;

360 buf_size = 0;

361 }

362

363 *(AVFrame *) data = cc->frame;

364 return buf_size;

365 }

366

367 static av_cold int cdg_decode_end(AVCodecContext *avctx)

368 {

369 CDGraphicsContext *cc = avctx->priv_data;

370

371 if (cc->frame.data[0])

372 avctx->release_buffer(avctx, &cc->frame);

373

374 return 0;

375 }

376

377 AVCodec ff_cdgraphics_decoder = {

378 .name = "cdgraphics",

379 .type = AVMEDIA_TYPE_VIDEO,

380 .id = AV_CODEC_ID_CDGRAPHICS,

381 .priv_data_size = sizeof(CDGraphicsContext),

382 .init = cdg_decode_init,

383 .close = cdg_decode_end,

384 .decode = cdg_decode_frame,

385 .capabilities = CODEC_CAP_DR1,

386 .long_name = NULL_IF_CONFIG_SMALL("CD Graphics video"),

387 };

Generated on Sat May 25 2013 03:58:32 for FFmpeg by doxygen 1.8.2