avcodec/h264: Declare the local variable decode_chroma as const.
[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 "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
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  */
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  */
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 };