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 s->frame = av_frame_alloc();

76 if (!s->frame)

77 return AVERROR(ENOMEM);

79 return 0;

80 }

82 static void msvideo1_decode_8bit(Msvideo1Context *s)

83 {

84 int block_ptr, pixel_ptr;

85 int total_blocks;

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

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

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

89 int block_inc;

90 int row_dec;

92 /* decoding parameters */

93 int stream_ptr;

94 unsigned char byte_a, byte_b;

95 unsigned short flags;

96 int skip_blocks;

97 unsigned char colors[8];

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

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

100

101 stream_ptr = 0;

102 skip_blocks = 0;

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

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

105 total_blocks = blocks_wide * blocks_high;

106 block_inc = 4;

107 row_dec = stride + 4;

108

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

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

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

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

113 if (skip_blocks) {

114 block_ptr += block_inc;

115 skip_blocks--;

116 total_blocks--;

117 continue;

118 }

119

120 pixel_ptr = block_ptr;

121

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

123 CHECK_STREAM_PTR(2);

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

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

126

127 /* check if the decode is finished */

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

129 return;

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

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

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

133 } else if (byte_b < 0x80) {

134 /* 2-color encoding */

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

136

137 CHECK_STREAM_PTR(2);

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

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

140

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

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

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

144 pixel_ptr -= row_dec;

145 }

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

147 /* 8-color encoding */

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

149

150 CHECK_STREAM_PTR(8);

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

152 stream_ptr += 8;

153

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

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

156 pixels[pixel_ptr++] =

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

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

159 pixel_ptr -= row_dec;

160 }

161 } else {

162 /* 1-color encoding */

163 colors[0] = byte_a;

164

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

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

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

168 pixel_ptr -= row_dec;

169 }

170 }

171

172 block_ptr += block_inc;

173 total_blocks--;

174 }

175 }

176

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

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

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

180 }

181

182 static void msvideo1_decode_16bit(Msvideo1Context *s)

183 {

184 int block_ptr, pixel_ptr;

185 int total_blocks;

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

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

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

189 int block_inc;

190 int row_dec;

191

192 /* decoding parameters */

193 int stream_ptr;

194 unsigned char byte_a, byte_b;

195 unsigned short flags;

196 int skip_blocks;

197 unsigned short colors[8];

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

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

200

201 stream_ptr = 0;

202 skip_blocks = 0;

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

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

205 total_blocks = blocks_wide * blocks_high;

206 block_inc = 4;

207 row_dec = stride + 4;

208

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

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

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

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

213 if (skip_blocks) {

214 block_ptr += block_inc;

215 skip_blocks--;

216 total_blocks--;

217 continue;

218 }

219

220 pixel_ptr = block_ptr;

221

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

223 CHECK_STREAM_PTR(2);

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

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

226

227 /* check if the decode is finished */

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

229 return;

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

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

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

233 } else if (byte_b < 0x80) {

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

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

236

237 CHECK_STREAM_PTR(4);

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

239 stream_ptr += 2;

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

241 stream_ptr += 2;

242

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

244 /* 8-color encoding */

245 CHECK_STREAM_PTR(12);

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

247 stream_ptr += 2;

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

249 stream_ptr += 2;

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

251 stream_ptr += 2;

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

253 stream_ptr += 2;

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

255 stream_ptr += 2;

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

257 stream_ptr += 2;

258

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

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

261 pixels[pixel_ptr++] =

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

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

264 pixel_ptr -= row_dec;

265 }

266 } else {

267 /* 2-color encoding */

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

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

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

271 pixel_ptr -= row_dec;

272 }

273 }

274 } else {

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

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

277

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

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

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

281 pixel_ptr -= row_dec;

282 }

283 }

284

285 block_ptr += block_inc;

286 total_blocks--;

287 }

288 }

289 }

290

291 static int msvideo1_decode_frame(AVCodecContext *avctx,

292 void *data, int *got_frame,

293 AVPacket *avpkt)

294 {

295 const uint8_t *buf = avpkt->data;

296 int buf_size = avpkt->size;

297 Msvideo1Context *s = avctx->priv_data;

298 int ret;

299

300 s->buf = buf;

301 s->size = buf_size;

302

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

304 return ret;

305

306 if (s->mode_8bit) {

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

308

309 if (pal) {

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

311 s->frame->palette_has_changed = 1;

312 }

313 }

314

315 if (s->mode_8bit)

316 msvideo1_decode_8bit(s);

317 else

318 msvideo1_decode_16bit(s);

319

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

321 return ret;

322

323 *got_frame = 1;

324

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

326 return buf_size;

327 }

328

329 static av_cold int msvideo1_decode_end(AVCodecContext *avctx)

330 {

331 Msvideo1Context *s = avctx->priv_data;

332

333 av_frame_free(&s->frame);

334

335 return 0;

336 }

337

338 AVCodec ff_msvideo1_decoder = {

339 .name = "msvideo1",

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

341 .type = AVMEDIA_TYPE_VIDEO,

342 .id = AV_CODEC_ID_MSVIDEO1,

343 .priv_data_size = sizeof(Msvideo1Context),

344 .init = msvideo1_decode_init,

345 .close = msvideo1_decode_end,

346 .decode = msvideo1_decode_frame,

347 .capabilities = CODEC_CAP_DR1,

348 };

Generated on Sat Jan 25 2014 19:51:52 for FFmpeg by doxygen 1.8.2