1 /*
2 * Microsoft Video-1 Encoder
3 * Copyright (c) 2009 Konstantin Shishkov
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 */
21
22 /**
23 * @file
24 * Microsoft Video-1 encoder
25 */
26
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 AVLFG rnd;
39 uint8_t *prev;
40
41 int block[16*3];
42 int block2[16*3];
43 int codebook[8*3];
44 int codebook2[8*3];
45 int output[16*3];
46 int output2[16*3];
47 int avg[3];
48 int bestpos;
49 int keyint;
50 } Msvideo1EncContext;
51
52 enum MSV1Mode{
53 MODE_SKIP = 0,
54 MODE_FILL,
55 MODE_2COL,
56 MODE_8COL,
57 };
58
59 #define SKIP_PREFIX 0x8400
60 #define SKIPS_MAX 0x03FF
61 #define MKRGB555(in, off) (((in)[off] << 10) | ((in)[(off) + 1] << 5) | ((in)[(off) + 2]))
62
63 static const int remap[16] = { 0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15 };
64
encode_frame(AVCodecContext * avctx,AVPacket * pkt,const AVFrame * pict,int * got_packet)65 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
66 const AVFrame *pict, int *got_packet)
67 {
68 Msvideo1EncContext * const c = avctx->priv_data;
69 const AVFrame *p = pict;
70 uint16_t *src;
71 uint8_t *prevptr;
72 uint8_t *dst, *buf;
73 int keyframe = 0;
74 int no_skips = 1;
75 int i, j, k, x, y, ret;
76 int skips = 0;
77 int quality = 24;
78
79 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*9 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
80 return ret;
81 dst= buf= pkt->data;
82
83 if(!c->prev)
84 c->prev = av_malloc(avctx->width * 3 * (avctx->height + 3));
85 prevptr = c->prev + avctx->width * 3 * (FFALIGN(avctx->height, 4) - 1);
86 src = (uint16_t*)(p->data[0] + p->linesize[0]*(FFALIGN(avctx->height, 4) - 1));
87 if(c->keyint >= avctx->keyint_min)
88 keyframe = 1;
89
90
91 for(y = 0; y < avctx->height; y += 4){
92 for(x = 0; x < avctx->width; x += 4){
93 int bestmode = MODE_SKIP;
94 int bestscore = INT_MAX;
95 int flags = 0;
96 int score;
97
98 for(j = 0; j < 4; j++){
99 for(i = 0; i < 4; i++){
100 uint16_t val = src[x + i - j*p->linesize[0]/2];
101 for(k = 0; k < 3; k++){
102 c->block[(i + j*4)*3 + k] =
103 c->block2[remap[i + j*4]*3 + k] = (val >> (10-k*5)) & 0x1F;
104 }
105 }
106 }
107 if(!keyframe){
108 bestscore = 0;
109 for(j = 0; j < 4; j++){
110 for(i = 0; i < 4*3; i++){
111 int t = prevptr[x*3 + i - j*3*avctx->width] - c->block[i + j*4*3];
112 bestscore += t*t;
113 }
114 }
115 bestscore /= quality;
116 }
117 // try to find optimal value to fill whole 4x4 block
118 score = 0;
119 avpriv_init_elbg(c->block, 3, 16, c->avg, 1, 1, c->output, &c->rnd);
120 avpriv_do_elbg (c->block, 3, 16, c->avg, 1, 1, c->output, &c->rnd);
121 if(c->avg[0] == 1) // red component = 1 will be written as skip code
122 c->avg[0] = 0;
123 for(j = 0; j < 4; j++){
124 for(i = 0; i < 4; i++){
125 for(k = 0; k < 3; k++){
126 int t = c->avg[k] - c->block[(i+j*4)*3+k];
127 score += t*t;
128 }
129 }
130 }
131 score /= quality;
132 score += 2;
133 if(score < bestscore){
134 bestscore = score;
135 bestmode = MODE_FILL;
136 }
137 // search for optimal filling of 2-color block
138 score = 0;
139 avpriv_init_elbg(c->block, 3, 16, c->codebook, 2, 1, c->output, &c->rnd);
140 avpriv_do_elbg (c->block, 3, 16, c->codebook, 2, 1, c->output, &c->rnd);
141 // last output value should be always 1, swap codebooks if needed
142 if(!c->output[15]){
143 for(i = 0; i < 3; i++)
144 FFSWAP(uint8_t, c->codebook[i], c->codebook[i+3]);
145 for(i = 0; i < 16; i++)
146 c->output[i] ^= 1;
147 }
148 for(j = 0; j < 4; j++){
149 for(i = 0; i < 4; i++){
150 for(k = 0; k < 3; k++){
151 int t = c->codebook[c->output[i+j*4]*3 + k] - c->block[i*3+k+j*4*3];
152 score += t*t;
153 }
154 }
155 }
156 score /= quality;
157 score += 6;
158 if(score < bestscore){
159 bestscore = score;
160 bestmode = MODE_2COL;
161 }
162 // search for optimal filling of 2-color 2x2 subblocks
163 score = 0;
164 for(i = 0; i < 4; i++){
165 avpriv_init_elbg(c->block2 + i*4*3, 3, 4, c->codebook2 + i*2*3, 2, 1, c->output2 + i*4, &c->rnd);
166 avpriv_do_elbg (c->block2 + i*4*3, 3, 4, c->codebook2 + i*2*3, 2, 1, c->output2 + i*4, &c->rnd);
167 }
168 // last value should be always 1, swap codebooks if needed
169 if(!c->output2[15]){
170 for(i = 0; i < 3; i++)
171 FFSWAP(uint8_t, c->codebook2[i+18], c->codebook2[i+21]);
172 for(i = 12; i < 16; i++)
173 c->output2[i] ^= 1;
174 }
175 for(j = 0; j < 4; j++){
176 for(i = 0; i < 4; i++){
177 for(k = 0; k < 3; k++){
178 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];
179 score += t*t;
180 }
181 }
182 }
183 score /= quality;
184 score += 18;
185 if(score < bestscore){
186 bestscore = score;
187 bestmode = MODE_8COL;
188 }
189
190 if(bestmode == MODE_SKIP){
191 skips++;
192 no_skips = 0;
193 }
194 if((bestmode != MODE_SKIP && skips) || skips == SKIPS_MAX){
195 bytestream_put_le16(&dst, skips | SKIP_PREFIX);
196 skips = 0;
197 }
198
199 switch(bestmode){
200 case MODE_FILL:
201 bytestream_put_le16(&dst, MKRGB555(c->avg,0) | 0x8000);
202 for(j = 0; j < 4; j++)
203 for(i = 0; i < 4; i++)
204 for(k = 0; k < 3; k++)
205 prevptr[x*3 + i*3 + k - j*3*avctx->width] = c->avg[k];
206 break;
207 case MODE_2COL:
208 for(j = 0; j < 4; j++){
209 for(i = 0; i < 4; i++){
210 flags |= (c->output[i + j*4]^1) << (i + j*4);
211 for(k = 0; k < 3; k++)
212 prevptr[x*3 + i*3 + k - j*3*avctx->width] = c->codebook[c->output[i + j*4]*3 + k];
213 }
214 }
215 bytestream_put_le16(&dst, flags);
216 bytestream_put_le16(&dst, MKRGB555(c->codebook, 0));
217 bytestream_put_le16(&dst, MKRGB555(c->codebook, 3));
218 break;
219 case MODE_8COL:
220 for(j = 0; j < 4; j++){
221 for(i = 0; i < 4; i++){
222 flags |= (c->output2[remap[i + j*4]]^1) << (i + j*4);
223 for(k = 0; k < 3; k++)
224 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];
225 }
226 }
227 bytestream_put_le16(&dst, flags);
228 bytestream_put_le16(&dst, MKRGB555(c->codebook2, 0) | 0x8000);
229 for(i = 3; i < 24; i += 3)
230 bytestream_put_le16(&dst, MKRGB555(c->codebook2, i));
231 break;
232 }
233 }
234 src -= p->linesize[0] << 1;
235 prevptr -= avctx->width * 3 * 4;
236 }
237 if(skips)
238 bytestream_put_le16(&dst, skips | SKIP_PREFIX);
239 //EOF
240 bytestream_put_byte(&dst, 0);
241 bytestream_put_byte(&dst, 0);
242
243 if(no_skips)
244 keyframe = 1;
245 if(keyframe)
246 c->keyint = 0;
247 else
248 c->keyint++;
249 if (keyframe) pkt->flags |= AV_PKT_FLAG_KEY;
250 pkt->size = dst - buf;
251 *got_packet = 1;
252
253 return 0;
254 }
255
256
257 /**
258 * init encoder
259 */
encode_init(AVCodecContext * avctx)260 static av_cold int encode_init(AVCodecContext *avctx)
261 {
262 Msvideo1EncContext * const c = avctx->priv_data;
263
264 c->avctx = avctx;
265 if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {
266 return -1;
267 }
268 if((avctx->width&3) || (avctx->height&3)){
269 av_log(avctx, AV_LOG_ERROR, "width and height must be multiples of 4\n");
270 return -1;
271 }
272
273 avctx->bits_per_coded_sample = 16;
274
275 c->keyint = avctx->keyint_min;
276 av_lfg_init(&c->rnd, 1);
277
278 return 0;
279 }
280
281
282
283 /**
284 * Uninit encoder
285 */
encode_end(AVCodecContext * avctx)286 static av_cold int encode_end(AVCodecContext *avctx)
287 {
288 Msvideo1EncContext * const c = avctx->priv_data;
289
290 av_freep(&c->prev);
291
292 return 0;
293 }
294
295 AVCodec ff_msvideo1_encoder = {
296 .name = "msvideo1",
297 .long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),
298 .type = AVMEDIA_TYPE_VIDEO,
299 .id = AV_CODEC_ID_MSVIDEO1,
300 .priv_data_size = sizeof(Msvideo1EncContext),
301 .init = encode_init,
302 .encode2 = encode_frame,
303 .close = encode_end,
304 .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_RGB555, AV_PIX_FMT_NONE},
305 };
306