doxygen: remove a few @file parameters.
[ffmpeg.git] / libavcodec / msvideo1enc.c
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 "bytestream.h"
29 #include "libavutil/lfg.h"
30 #include "elbg.h"
31 #include "libavutil/imgutils.h"
32 /**
33  * Encoder context
34  */
35 typedef struct Msvideo1EncContext {
36     AVCodecContext *avctx;
37     AVFrame pic;
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 0x0FFF
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
65 static int encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data)
66 {
67     Msvideo1EncContext * const c = avctx->priv_data;
68     AVFrame *pict = data;
69     AVFrame * const p = &c->pic;
70     uint16_t *src;
71     uint8_t *prevptr;
72     uint8_t *dst = buf;
73     int keyframe = 1;
74     int no_skips = 1;
75     int i, j, k, x, y;
76     int skips = 0;
77
78     *p = *pict;
79     if(!c->prev)
80         c->prev = av_malloc(avctx->width * 3 * (avctx->height + 3));
81     prevptr = c->prev + avctx->width * 3 * (FFALIGN(avctx->height, 4) - 1);
82     src = (uint16_t*)(p->data[0] + p->linesize[0]*(FFALIGN(avctx->height, 4) - 1));
83     if(c->keyint >= avctx->keyint_min)
84         keyframe = 1;
85
86     p->quality = 24;
87
88     for(y = 0; y < avctx->height; y += 4){
89         for(x = 0; x < avctx->width; x += 4){
90             int bestmode = MODE_SKIP;
91             int bestscore = INT_MAX;
92             int flags = 0;
93             int score;
94
95             for(j = 0; j < 4; j++){
96                 for(i = 0; i < 4; i++){
97                     uint16_t val = src[x + i - j*p->linesize[0]/2];
98                     for(k = 0; k < 3; k++){
99                         c->block[(i + j*4)*3 + k] =
100                         c->block2[remap[i + j*4]*3 + k] = (val >> (10-k*5)) & 0x1F;
101                     }
102                 }
103             }
104             if(!keyframe){
105                 bestscore = 0;
106                 for(j = 0; j < 4; j++){
107                     for(i = 0; i < 4*3; i++){
108                         int t = prevptr[x*3 + i + j*p->linesize[0]] - c->block[i + j*4*3];
109                         bestscore += t*t;
110                     }
111                 }
112                 bestscore /= p->quality;
113             }
114             // try to find optimal value to fill whole 4x4 block
115             score = 0;
116             ff_init_elbg(c->block, 3, 16, c->avg, 1, 1, c->output, &c->rnd);
117             ff_do_elbg  (c->block, 3, 16, c->avg, 1, 1, c->output, &c->rnd);
118             if(c->avg[0] == 1) // red component = 1 will be written as skip code
119                 c->avg[0] = 0;
120             for(j = 0; j < 4; j++){
121                 for(i = 0; i < 4; i++){
122                     for(k = 0; k < 3; k++){
123                         int t = c->avg[k] - c->block[(i+j*4)*3+k];
124                         score += t*t;
125                     }
126                 }
127             }
128             score /= p->quality;
129             score += 2;
130             if(score < bestscore){
131                 bestscore = score;
132                 bestmode = MODE_FILL;
133             }
134             // search for optimal filling of 2-color block
135             score = 0;
136             ff_init_elbg(c->block, 3, 16, c->codebook, 2, 1, c->output, &c->rnd);
137             ff_do_elbg  (c->block, 3, 16, c->codebook, 2, 1, c->output, &c->rnd);
138             // last output value should be always 1, swap codebooks if needed
139             if(!c->output[15]){
140                 for(i = 0; i < 3; i++)
141                     FFSWAP(uint8_t, c->codebook[i], c->codebook[i+3]);
142                 for(i = 0; i < 16; i++)
143                     c->output[i] ^= 1;
144             }
145             for(j = 0; j < 4; j++){
146                 for(i = 0; i < 4; i++){
147                     for(k = 0; k < 3; k++){
148                         int t = c->codebook[c->output[i+j*4]*3 + k] - c->block[i*3+k+j*4*3];
149                         score += t*t;
150                     }
151                 }
152             }
153             score /= p->quality;
154             score += 6;
155             if(score < bestscore){
156                 bestscore = score;
157                 bestmode = MODE_2COL;
158             }
159             // search for optimal filling of 2-color 2x2 subblocks
160             score = 0;
161             for(i = 0; i < 4; i++){
162                 ff_init_elbg(c->block2 + i*4*3, 3, 4, c->codebook2 + i*2*3, 2, 1, c->output2 + i*4, &c->rnd);
163                 ff_do_elbg  (c->block2 + i*4*3, 3, 4, c->codebook2 + i*2*3, 2, 1, c->output2 + i*4, &c->rnd);
164             }
165             // last value should be always 1, swap codebooks if needed
166             if(!c->output2[15]){
167                 for(i = 0; i < 3; i++)
168                     FFSWAP(uint8_t, c->codebook2[i+18], c->codebook2[i+21]);
169                 for(i = 12; i < 16; i++)
170                     c->output2[i] ^= 1;
171             }
172             for(j = 0; j < 4; j++){
173                 for(i = 0; i < 4; i++){
174                     for(k = 0; k < 3; k++){
175                         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];
176                         score += t*t;
177                     }
178                 }
179             }
180             score /= p->quality;
181             score += 18;
182             if(score < bestscore){
183                 bestscore = score;
184                 bestmode = MODE_8COL;
185             }
186
187             if(bestmode == MODE_SKIP){
188                 skips++;
189                 no_skips = 0;
190             }
191             if((bestmode != MODE_SKIP && skips) || skips == SKIPS_MAX){
192                 bytestream_put_le16(&dst, skips | SKIP_PREFIX);
193                 skips = 0;
194             }
195
196             switch(bestmode){
197             case MODE_FILL:
198                 bytestream_put_le16(&dst, MKRGB555(c->avg,0) | 0x8000);
199                 for(j = 0; j < 4; j++)
200                     for(i = 0; i < 4; i++)
201                         for(k = 0; k < 3; k++)
202                             prevptr[i*3 + k - j*3*avctx->width] = c->avg[k];
203                 break;
204             case MODE_2COL:
205                 for(j = 0; j < 4; j++){
206                     for(i = 0; i < 4; i++){
207                         flags |= (c->output[i + j*4]^1) << (i + j*4);
208                         for(k = 0; k < 3; k++)
209                             prevptr[i*3 + k - j*3*avctx->width] = c->codebook[c->output[i + j*4]*3 + k];
210                     }
211                 }
212                 bytestream_put_le16(&dst, flags);
213                 bytestream_put_le16(&dst, MKRGB555(c->codebook, 0));
214                 bytestream_put_le16(&dst, MKRGB555(c->codebook, 3));
215                 break;
216             case MODE_8COL:
217                 for(j = 0; j < 4; j++){
218                     for(i = 0; i < 4; i++){
219                         flags |= (c->output2[remap[i + j*4]]^1) << (i + j*4);
220                         for(k = 0; k < 3; k++)
221                             prevptr[i*3 + k - j*3*avctx->width] = c->codebook2[(c->output2[remap[i+j*4]] + (i&2) + (j&2)*2)*3 + k];
222                     }
223                 }
224                 bytestream_put_le16(&dst, flags);
225                 bytestream_put_le16(&dst, MKRGB555(c->codebook2, 0) | 0x8000);
226                 for(i = 3; i < 24; i += 3)
227                     bytestream_put_le16(&dst, MKRGB555(c->codebook2, i));
228                 break;
229             }
230         }
231         src     -= p->linesize[0] << 1;
232         prevptr -= avctx->width * 3 * 4;
233     }
234     if(skips)
235         bytestream_put_le16(&dst, skips | SKIP_PREFIX);
236     //EOF
237     bytestream_put_byte(&dst, 0);
238     bytestream_put_byte(&dst, 0);
239
240     if(no_skips)
241         keyframe = 1;
242     if(keyframe)
243         c->keyint = 0;
244     else
245         c->keyint++;
246     p->pict_type= keyframe ? FF_I_TYPE : FF_P_TYPE;
247     p->key_frame= keyframe;
248
249     return dst - buf;
250 }
251
252
253 /**
254  * init encoder
255  */
256 static av_cold int encode_init(AVCodecContext *avctx)
257 {
258     Msvideo1EncContext * const c = avctx->priv_data;
259
260     c->avctx = avctx;
261     if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {
262         return -1;
263     }
264
265     avcodec_get_frame_defaults(&c->pic);
266     avctx->coded_frame = (AVFrame*)&c->pic;
267
268     c->keyint = avctx->keyint_min;
269     av_lfg_init(&c->rnd, 1);
270
271     return 0;
272 }
273
274
275
276 /**
277  * Uninit encoder
278  */
279 static av_cold int encode_end(AVCodecContext *avctx)
280 {
281     Msvideo1EncContext * const c = avctx->priv_data;
282
283     av_freep(&c->prev);
284
285     return 0;
286 }
287
288 AVCodec ff_msvideo1_encoder = {
289     "msvideo1",
290     AVMEDIA_TYPE_VIDEO,
291     CODEC_ID_MSVIDEO1,
292     sizeof(Msvideo1EncContext),
293     encode_init,
294     encode_frame,
295     encode_end,
296     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_RGB555, PIX_FMT_NONE},
297     .long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),
298 };