FFmpeg: libavcodec/msvideo1.c Source File

FFmpeg

[フレーム]

libavcodec

msvideo1.c

Go to the documentation of this file.

1 /*

2 * Microsoft Video-1 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 Video-1 Decoder by Mike Melanson (melanson@pcisys.net)

25 * For more information about the MS Video-1 format, visit:

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

27 *

28 */

30 #include <stdio.h>

31 #include <stdlib.h>

32 #include <string.h>

34 #include "libavutil/internal.h"

35 #include "libavutil/intreadwrite.h"

36 #include "avcodec.h"

37 #include "internal.h"

39 #define PALETTE_COUNT 256

40 #define CHECK_STREAM_PTR(n) \

41 if ((stream_ptr + n) > s->size ) { \

42 av_log(s->avctx, AV_LOG_ERROR, " MS Video-1 warning: stream_ptr out of bounds (%d >= %d)\n", \

43 stream_ptr + n, s->size); \

44 return; \

45 }

47 typedef struct Msvideo1Context {

49 AVCodecContext *avctx;

50 AVFrame frame;

52 const unsigned char *buf;

53 int size;

55 int mode_8bit; /* if it's not 8-bit, it's 16-bit */

57 uint32_t pal[256];

58 } Msvideo1Context;

60 static av_cold int msvideo1_decode_init(AVCodecContext *avctx)

61 {

62 Msvideo1Context *s = avctx->priv_data;

64 s->avctx = avctx;

66 /* figure out the colorspace based on the presence of a palette */

67 if (s->avctx->bits_per_coded_sample == 8) {

68 s->mode_8bit = 1;

69 avctx->pix_fmt = AV_PIX_FMT_PAL8;

70 } else {

71 s->mode_8bit = 0;

72 avctx->pix_fmt = AV_PIX_FMT_RGB555;

73 }

75 avcodec_get_frame_defaults(&s->frame);

77 return 0;

78 }

80 static void msvideo1_decode_8bit(Msvideo1Context *s)

81 {

82 int block_ptr, pixel_ptr;

83 int total_blocks;

84 int pixel_x, pixel_y; /* pixel width and height iterators */

85 int block_x, block_y; /* block width and height iterators */

86 int blocks_wide, blocks_high; /* width and height in 4x4 blocks */

87 int block_inc;

88 int row_dec;

90 /* decoding parameters */

91 int stream_ptr;

92 unsigned char byte_a, byte_b;

93 unsigned short flags;

94 int skip_blocks;

95 unsigned char colors[8];

96 unsigned char *pixels = s->frame.data[0];

97 int stride = s->frame.linesize[0];

99 stream_ptr = 0;

100 skip_blocks = 0;

101 blocks_wide = s->avctx->width / 4;

102 blocks_high = s->avctx->height / 4;

103 total_blocks = blocks_wide * blocks_high;

104 block_inc = 4;

105 row_dec = stride + 4;

106

107 for (block_y = blocks_high; block_y > 0; block_y--) {

108 block_ptr = ((block_y * 4) - 1) * stride;

109 for (block_x = blocks_wide; block_x > 0; block_x--) {

110 /* check if this block should be skipped */

111 if (skip_blocks) {

112 block_ptr += block_inc;

113 skip_blocks--;

114 total_blocks--;

115 continue;

116 }

117

118 pixel_ptr = block_ptr;

119

120 /* get the next two bytes in the encoded data stream */

121 CHECK_STREAM_PTR(2);

122 byte_a = s->buf[stream_ptr++];

123 byte_b = s->buf[stream_ptr++];

124

125 /* check if the decode is finished */

126 if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0))

127 return;

128 else if ((byte_b & 0xFC) == 0x84) {

129 /* skip code, but don't count the current block */

130 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;

131 } else if (byte_b < 0x80) {

132 /* 2-color encoding */

133 flags = (byte_b << 8) | byte_a;

134

135 CHECK_STREAM_PTR(2);

136 colors[0] = s->buf[stream_ptr++];

137 colors[1] = s->buf[stream_ptr++];

138

139 for (pixel_y = 0; pixel_y < 4; pixel_y++) {

140 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)

141 pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];

142 pixel_ptr -= row_dec;

143 }

144 } else if (byte_b >= 0x90) {

145 /* 8-color encoding */

146 flags = (byte_b << 8) | byte_a;

147

148 CHECK_STREAM_PTR(8);

149 memcpy(colors, &s->buf[stream_ptr], 8);

150 stream_ptr += 8;

151

152 for (pixel_y = 0; pixel_y < 4; pixel_y++) {

153 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)

154 pixels[pixel_ptr++] =

155 colors[((pixel_y & 0x2) << 1) +

156 (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];

157 pixel_ptr -= row_dec;

158 }

159 } else {

160 /* 1-color encoding */

161 colors[0] = byte_a;

162

163 for (pixel_y = 0; pixel_y < 4; pixel_y++) {

164 for (pixel_x = 0; pixel_x < 4; pixel_x++)

165 pixels[pixel_ptr++] = colors[0];

166 pixel_ptr -= row_dec;

167 }

168 }

169

170 block_ptr += block_inc;

171 total_blocks--;

172 }

173 }

174

175 /* make the palette available on the way out */

176 if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)

177 memcpy(s->frame.data[1], s->pal, AVPALETTE_SIZE);

178 }

179

180 static void msvideo1_decode_16bit(Msvideo1Context *s)

181 {

182 int block_ptr, pixel_ptr;

183 int total_blocks;

184 int pixel_x, pixel_y; /* pixel width and height iterators */

185 int block_x, block_y; /* block width and height iterators */

186 int blocks_wide, blocks_high; /* width and height in 4x4 blocks */

187 int block_inc;

188 int row_dec;

189

190 /* decoding parameters */

191 int stream_ptr;

192 unsigned char byte_a, byte_b;

193 unsigned short flags;

194 int skip_blocks;

195 unsigned short colors[8];

196 unsigned short *pixels = (unsigned short *)s->frame.data[0];

197 int stride = s->frame.linesize[0] / 2;

198

199 stream_ptr = 0;

200 skip_blocks = 0;

201 blocks_wide = s->avctx->width / 4;

202 blocks_high = s->avctx->height / 4;

203 total_blocks = blocks_wide * blocks_high;

204 block_inc = 4;

205 row_dec = stride + 4;

206

207 for (block_y = blocks_high; block_y > 0; block_y--) {

208 block_ptr = ((block_y * 4) - 1) * stride;

209 for (block_x = blocks_wide; block_x > 0; block_x--) {

210 /* check if this block should be skipped */

211 if (skip_blocks) {

212 block_ptr += block_inc;

213 skip_blocks--;

214 total_blocks--;

215 continue;

216 }

217

218 pixel_ptr = block_ptr;

219

220 /* get the next two bytes in the encoded data stream */

221 CHECK_STREAM_PTR(2);

222 byte_a = s->buf[stream_ptr++];

223 byte_b = s->buf[stream_ptr++];

224

225 /* check if the decode is finished */

226 if ((byte_a == 0) && (byte_b == 0) && (total_blocks == 0)) {

227 return;

228 } else if ((byte_b & 0xFC) == 0x84) {

229 /* skip code, but don't count the current block */

230 skip_blocks = ((byte_b - 0x84) << 8) + byte_a - 1;

231 } else if (byte_b < 0x80) {

232 /* 2- or 8-color encoding modes */

233 flags = (byte_b << 8) | byte_a;

234

235 CHECK_STREAM_PTR(4);

236 colors[0] = AV_RL16(&s->buf[stream_ptr]);

237 stream_ptr += 2;

238 colors[1] = AV_RL16(&s->buf[stream_ptr]);

239 stream_ptr += 2;

240

241 if (colors[0] & 0x8000) {

242 /* 8-color encoding */

243 CHECK_STREAM_PTR(12);

244 colors[2] = AV_RL16(&s->buf[stream_ptr]);

245 stream_ptr += 2;

246 colors[3] = AV_RL16(&s->buf[stream_ptr]);

247 stream_ptr += 2;

248 colors[4] = AV_RL16(&s->buf[stream_ptr]);

249 stream_ptr += 2;

250 colors[5] = AV_RL16(&s->buf[stream_ptr]);

251 stream_ptr += 2;

252 colors[6] = AV_RL16(&s->buf[stream_ptr]);

253 stream_ptr += 2;

254 colors[7] = AV_RL16(&s->buf[stream_ptr]);

255 stream_ptr += 2;

256

257 for (pixel_y = 0; pixel_y < 4; pixel_y++) {

258 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)

259 pixels[pixel_ptr++] =

260 colors[((pixel_y & 0x2) << 1) +

261 (pixel_x & 0x2) + ((flags & 0x1) ^ 1)];

262 pixel_ptr -= row_dec;

263 }

264 } else {

265 /* 2-color encoding */

266 for (pixel_y = 0; pixel_y < 4; pixel_y++) {

267 for (pixel_x = 0; pixel_x < 4; pixel_x++, flags >>= 1)

268 pixels[pixel_ptr++] = colors[(flags & 0x1) ^ 1];

269 pixel_ptr -= row_dec;

270 }

271 }

272 } else {

273 /* otherwise, it's a 1-color block */

274 colors[0] = (byte_b << 8) | byte_a;

275

276 for (pixel_y = 0; pixel_y < 4; pixel_y++) {

277 for (pixel_x = 0; pixel_x < 4; pixel_x++)

278 pixels[pixel_ptr++] = colors[0];

279 pixel_ptr -= row_dec;

280 }

281 }

282

283 block_ptr += block_inc;

284 total_blocks--;

285 }

286 }

287 }

288

289 static int msvideo1_decode_frame(AVCodecContext *avctx,

290 void *data, int *got_frame,

291 AVPacket *avpkt)

292 {

293 const uint8_t *buf = avpkt->data;

294 int buf_size = avpkt->size;

295 Msvideo1Context *s = avctx->priv_data;

296 int ret;

297

298 s->buf = buf;

299 s->size = buf_size;

300

301 if ((ret = ff_reget_buffer(avctx, &s->frame)) < 0)

302 return ret;

303

304 if (s->mode_8bit) {

305 const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);

306

307 if (pal) {

308 memcpy(s->pal, pal, AVPALETTE_SIZE);

309 s->frame.palette_has_changed = 1;

310 }

311 }

312

313 if (s->mode_8bit)

314 msvideo1_decode_8bit(s);

315 else

316 msvideo1_decode_16bit(s);

317

318 if ((ret = av_frame_ref(data, &s->frame)) < 0)

319 return ret;

320

321 *got_frame = 1;

322

323 /* report that the buffer was completely consumed */

324 return buf_size;

325 }

326

327 static av_cold int msvideo1_decode_end(AVCodecContext *avctx)

328 {

329 Msvideo1Context *s = avctx->priv_data;

330

331 av_frame_unref(&s->frame);

332

333 return 0;

334 }

335

336 AVCodec ff_msvideo1_decoder = {

337 .name = "msvideo1",

338 .type = AVMEDIA_TYPE_VIDEO,

339 .id = AV_CODEC_ID_MSVIDEO1,

340 .priv_data_size = sizeof(Msvideo1Context),

341 .init = msvideo1_decode_init,

342 .close = msvideo1_decode_end,

343 .decode = msvideo1_decode_frame,

344 .capabilities = CODEC_CAP_DR1,

345 .long_name = NULL_IF_CONFIG_SMALL("Microsoft Video 1"),

346 };

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