FFmpeg: libavcodec/msvideo1enc.c Source File

FFmpeg

[フレーム]

libavcodec

msvideo1enc.c

Go to the documentation of this file.

1 /*

2 * Microsoft Video-1 Encoder

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 encoder

25 */

27 #include "avcodec.h"

28 #include "internal.h"

29 #include "bytestream.h"

30 #include "libavutil/lfg.h"

31 #include "elbg.h"

32 #include "libavutil/imgutils.h"

33 /**

34 * Encoder context

35 */

36 typedef struct Msvideo1EncContext {

37 AVCodecContext *avctx;

38 AVFrame pic;

39 AVLFG rnd;

40 uint8_t *prev;

42 int block[16*3];

43 int block2[16*3];

44 int codebook[8*3];

45 int codebook2[8*3];

46 int output[16*3];

47 int output2[16*3];

48 int avg[3];

49 int bestpos;

50 int keyint;

51 } Msvideo1EncContext;

53 enum MSV1Mode{

54 MODE_SKIP = 0,

55 MODE_FILL,

56 MODE_2COL,

57 MODE_8COL,

58 };

60 #define SKIP_PREFIX 0x8400

61 #define SKIPS_MAX 0x0FFF

62 #define MKRGB555(in, off) ((in[off] << 10) | (in[off + 1] << 5) | (in[off + 2]))

64 static const int remap[16] = { 0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15 };

66 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

67 const AVFrame *pict, int *got_packet)

68 {

69 Msvideo1EncContext * const c = avctx->priv_data;

70 AVFrame * const p = &c->pic;

71 uint16_t *src;

72 uint8_t *prevptr;

73 uint8_t *dst, *buf;

74 int keyframe = 0;

75 int no_skips = 1;

76 int i, j, k, x, y, ret;

77 int skips = 0;

79 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*9 + FF_MIN_BUFFER_SIZE)) < 0)

80 return ret;

81 dst= buf= pkt->data;

83 *p = *pict;

84 if(!c->prev)

85 c->prev = av_malloc(avctx->width * 3 * (avctx->height + 3));

86 prevptr = c->prev + avctx->width * 3 * (FFALIGN(avctx->height, 4) - 1);

87 src = (uint16_t*)(p->data[0] + p->linesize[0]*(FFALIGN(avctx->height, 4) - 1));

88 if(c->keyint >= avctx->keyint_min)

89 keyframe = 1;

91 p->quality = 24;

93 for(y = 0; y < avctx->height; y += 4){

94 for(x = 0; x < avctx->width; x += 4){

95 int bestmode = MODE_SKIP;

96 int bestscore = INT_MAX;

97 int flags = 0;

98 int score;

100 for(j = 0; j < 4; j++){

101 for(i = 0; i < 4; i++){

102 uint16_t val = src[x + i - j*p->linesize[0]/2];

103 for(k = 0; k < 3; k++){

104 c->block[(i + j*4)*3 + k] =

105 c->block2[remap[i + j*4]*3 + k] = (val >> (10-k*5)) & 0x1F;

106 }

107 }

108 }

109 if(!keyframe){

110 bestscore = 0;

111 for(j = 0; j < 4; j++){

112 for(i = 0; i < 4*3; i++){

113 int t = prevptr[x*3 + i - j*3*avctx->width] - c->block[i + j*4*3];

114 bestscore += t*t;

115 }

116 }

117 bestscore /= p->quality;

118 }

119 // try to find optimal value to fill whole 4x4 block

120 score = 0;

121 ff_init_elbg(c->block, 3, 16, c->avg, 1, 1, c->output, &c->rnd);

122 ff_do_elbg (c->block, 3, 16, c->avg, 1, 1, c->output, &c->rnd);

123 if(c->avg[0] == 1) // red component = 1 will be written as skip code

124 c->avg[0] = 0;

125 for(j = 0; j < 4; j++){

126 for(i = 0; i < 4; i++){

127 for(k = 0; k < 3; k++){

128 int t = c->avg[k] - c->block[(i+j*4)*3+k];

129 score += t*t;

130 }

131 }

132 }

133 score /= p->quality;

134 score += 2;

135 if(score < bestscore){

136 bestscore = score;

137 bestmode = MODE_FILL;

138 }

139 // search for optimal filling of 2-color block

140 score = 0;

141 ff_init_elbg(c->block, 3, 16, c->codebook, 2, 1, c->output, &c->rnd);

142 ff_do_elbg (c->block, 3, 16, c->codebook, 2, 1, c->output, &c->rnd);

143 // last output value should be always 1, swap codebooks if needed

144 if(!c->output[15]){

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

146 FFSWAP(uint8_t, c->codebook[i], c->codebook[i+3]);

147 for(i = 0; i < 16; i++)

148 c->output[i] ^= 1;

149 }

150 for(j = 0; j < 4; j++){

151 for(i = 0; i < 4; i++){

152 for(k = 0; k < 3; k++){

153 int t = c->codebook[c->output[i+j*4]*3 + k] - c->block[i*3+k+j*4*3];

154 score += t*t;

155 }

156 }

157 }

158 score /= p->quality;

159 score += 6;

160 if(score < bestscore){

161 bestscore = score;

162 bestmode = MODE_2COL;

163 }

164 // search for optimal filling of 2-color 2x2 subblocks

165 score = 0;

166 for(i = 0; i < 4; i++){

167 ff_init_elbg(c->block2 + i*4*3, 3, 4, c->codebook2 + i*2*3, 2, 1, c->output2 + i*4, &c->rnd);

168 ff_do_elbg (c->block2 + i*4*3, 3, 4, c->codebook2 + i*2*3, 2, 1, c->output2 + i*4, &c->rnd);

169 }

170 // last value should be always 1, swap codebooks if needed

171 if(!c->output2[15]){

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

173 FFSWAP(uint8_t, c->codebook2[i+18], c->codebook2[i+21]);

174 for(i = 12; i < 16; i++)

175 c->output2[i] ^= 1;

176 }

177 for(j = 0; j < 4; j++){

178 for(i = 0; i < 4; i++){

179 for(k = 0; k < 3; k++){

180 int t = c->codebook2[(c->output2[remap[i+j*4]] + (i&2) + (j&2)*2)*3+k] - c->block[i*3+k + j*4*3];

181 score += t*t;

182 }

183 }

184 }

185 score /= p->quality;

186 score += 18;

187 if(score < bestscore){

188 bestscore = score;

189 bestmode = MODE_8COL;

190 }

191

192 if(bestmode == MODE_SKIP){

193 skips++;

194 no_skips = 0;

195 }

196 if((bestmode != MODE_SKIP && skips) || skips == SKIPS_MAX){

197 bytestream_put_le16(&dst, skips | SKIP_PREFIX);

198 skips = 0;

199 }

200

201 switch(bestmode){

202 case MODE_FILL:

203 bytestream_put_le16(&dst, MKRGB555(c->avg,0) | 0x8000);

204 for(j = 0; j < 4; j++)

205 for(i = 0; i < 4; i++)

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

207 prevptr[x*3 + i*3 + k - j*3*avctx->width] = c->avg[k];

208 break;

209 case MODE_2COL:

210 for(j = 0; j < 4; j++){

211 for(i = 0; i < 4; i++){

212 flags |= (c->output[i + j*4]^1) << (i + j*4);

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

214 prevptr[x*3 + i*3 + k - j*3*avctx->width] = c->codebook[c->output[i + j*4]*3 + k];

215 }

216 }

217 bytestream_put_le16(&dst, flags);

218 bytestream_put_le16(&dst, MKRGB555(c->codebook, 0));

219 bytestream_put_le16(&dst, MKRGB555(c->codebook, 3));

220 break;

221 case MODE_8COL:

222 for(j = 0; j < 4; j++){

223 for(i = 0; i < 4; i++){

224 flags |= (c->output2[remap[i + j*4]]^1) << (i + j*4);

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

226 prevptr[x*3 + i*3 + k - j*3*avctx->width] = c->codebook2[(c->output2[remap[i+j*4]] + (i&2) + (j&2)*2)*3 + k];

227 }

228 }

229 bytestream_put_le16(&dst, flags);

230 bytestream_put_le16(&dst, MKRGB555(c->codebook2, 0) | 0x8000);

231 for(i = 3; i < 24; i += 3)

232 bytestream_put_le16(&dst, MKRGB555(c->codebook2, i));

233 break;

234 }

235 }

236 src -= p->linesize[0] << 1;

237 prevptr -= avctx->width * 3 * 4;

238 }

239 if(skips)

240 bytestream_put_le16(&dst, skips | SKIP_PREFIX);

241 //EOF

242 bytestream_put_byte(&dst, 0);

243 bytestream_put_byte(&dst, 0);

244

245 if(no_skips)

246 keyframe = 1;

247 if(keyframe)

248 c->keyint = 0;

249 else

250 c->keyint++;

251 p->pict_type= keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

252 p->key_frame= keyframe;

253 if (keyframe) pkt->flags |= AV_PKT_FLAG_KEY;

254 pkt->size = dst - buf;

255 *got_packet = 1;

256

257 return 0;

258 }

259

260

261 /**

262 * init encoder

263 */

264 static av_cold int encode_init(AVCodecContext *avctx)

265 {

266 Msvideo1EncContext * const c = avctx->priv_data;

267

268 c->avctx = avctx;

269 if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {

270 return -1;

271 }

272 if((avctx->width&3) || (avctx->height&3)){

273 av_log(avctx, AV_LOG_ERROR, "width and height must be multiplies of 4\n");

274 return -1;

275 }

276

277 avcodec_get_frame_defaults(&c->pic);

278 avctx->coded_frame = (AVFrame*)&c->pic;

279 avctx->bits_per_coded_sample = 16;

280

281 c->keyint = avctx->keyint_min;

282 av_lfg_init(&c->rnd, 1);

283

284 return 0;

285 }

286

287

288

289 /**

290 * Uninit encoder

291 */

292 static av_cold int encode_end(AVCodecContext *avctx)

293 {

294 Msvideo1EncContext * const c = avctx->priv_data;

295

296 av_freep(&c->prev);

297

298 return 0;

299 }

300

301 AVCodec ff_msvideo1_encoder = {

302 .name = "msvideo1",

303 .type = AVMEDIA_TYPE_VIDEO,

304 .id = AV_CODEC_ID_MSVIDEO1,

305 .priv_data_size = sizeof(Msvideo1EncContext),

306 .init = encode_init,

307 .encode2 = encode_frame,

308 .close = encode_end,

309 .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_RGB555, AV_PIX_FMT_NONE},

310 .long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),

311 };

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