aic: Fix slice size computation for widths multiples of 32 macroblocks
[ffmpeg.git] / libavcodec / asvenc.c
1 /*
2  * Copyright (c) 2003 Michael Niedermayer
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * ASUS V1/V2 encoder.
24  */
25
26 #include "libavutil/attributes.h"
27 #include "libavutil/mem.h"
28
29 #include "asv.h"
30 #include "avcodec.h"
31 #include "fdctdsp.h"
32 #include "internal.h"
33 #include "mathops.h"
34 #include "mpeg12data.h"
35
36 static inline void asv2_put_bits(PutBitContext *pb, int n, int v)
37 {
38     put_bits(pb, n, ff_reverse[v << (8 - n)]);
39 }
40
41 static inline void asv1_put_level(PutBitContext *pb, int level)
42 {
43     unsigned int index = level + 3;
44
45     if (index <= 6) {
46         put_bits(pb, ff_asv_level_tab[index][1], ff_asv_level_tab[index][0]);
47     } else {
48         put_bits(pb, ff_asv_level_tab[3][1], ff_asv_level_tab[3][0]);
49         put_sbits(pb, 8, level);
50     }
51 }
52
53 static inline void asv2_put_level(PutBitContext *pb, int level)
54 {
55     unsigned int index = level + 31;
56
57     if (index <= 62) {
58         put_bits(pb, ff_asv2_level_tab[index][1], ff_asv2_level_tab[index][0]);
59     } else {
60         put_bits(pb, ff_asv2_level_tab[31][1], ff_asv2_level_tab[31][0]);
61         asv2_put_bits(pb, 8, level & 0xFF);
62     }
63 }
64
65 static inline void asv1_encode_block(ASV1Context *a, int16_t block[64])
66 {
67     int i;
68     int nc_count = 0;
69
70     put_bits(&a->pb, 8, (block[0] + 32) >> 6);
71     block[0] = 0;
72
73     for (i = 0; i < 10; i++) {
74         const int index = ff_asv_scantab[4 * i];
75         int ccp         = 0;
76
77         if ((block[index + 0] = (block[index + 0] *
78                                  a->q_intra_matrix[index + 0] + (1 << 15)) >> 16))
79             ccp |= 8;
80         if ((block[index + 8] = (block[index + 8] *
81                                  a->q_intra_matrix[index + 8] + (1 << 15)) >> 16))
82             ccp |= 4;
83         if ((block[index + 1] = (block[index + 1] *
84                                  a->q_intra_matrix[index + 1] + (1 << 15)) >> 16))
85             ccp |= 2;
86         if ((block[index + 9] = (block[index + 9] *
87                                  a->q_intra_matrix[index + 9] + (1 << 15)) >> 16))
88             ccp |= 1;
89
90         if (ccp) {
91             for (; nc_count; nc_count--)
92                 put_bits(&a->pb, ff_asv_ccp_tab[0][1], ff_asv_ccp_tab[0][0]);
93
94             put_bits(&a->pb, ff_asv_ccp_tab[ccp][1], ff_asv_ccp_tab[ccp][0]);
95
96             if (ccp & 8)
97                 asv1_put_level(&a->pb, block[index + 0]);
98             if (ccp & 4)
99                 asv1_put_level(&a->pb, block[index + 8]);
100             if (ccp & 2)
101                 asv1_put_level(&a->pb, block[index + 1]);
102             if (ccp & 1)
103                 asv1_put_level(&a->pb, block[index + 9]);
104         } else {
105             nc_count++;
106         }
107     }
108     put_bits(&a->pb, ff_asv_ccp_tab[16][1], ff_asv_ccp_tab[16][0]);
109 }
110
111 static inline int asv2_encode_block(ASV1Context *a, int16_t block[64])
112 {
113     int i;
114     int count = 0;
115
116     for (count = 63; count > 3; count--) {
117         const int index = ff_asv_scantab[count];
118         if ((block[index] * a->q_intra_matrix[index] + (1 << 15)) >> 16)
119             break;
120     }
121
122     count >>= 2;
123
124     asv2_put_bits(&a->pb, 4, count);
125     asv2_put_bits(&a->pb, 8, (block[0] + 32) >> 6);
126     block[0] = 0;
127
128     for (i = 0; i <= count; i++) {
129         const int index = ff_asv_scantab[4 * i];
130         int ccp         = 0;
131
132         if ((block[index + 0] = (block[index + 0] *
133                                  a->q_intra_matrix[index + 0] + (1 << 15)) >> 16))
134             ccp |= 8;
135         if ((block[index + 8] = (block[index + 8] *
136                                  a->q_intra_matrix[index + 8] + (1 << 15)) >> 16))
137             ccp |= 4;
138         if ((block[index + 1] = (block[index + 1] *
139                                  a->q_intra_matrix[index + 1] + (1 << 15)) >> 16))
140             ccp |= 2;
141         if ((block[index + 9] = (block[index + 9] *
142                                  a->q_intra_matrix[index + 9] + (1 << 15)) >> 16))
143             ccp |= 1;
144
145         if (!i && ccp >= 8)
146             return AVERROR_BUG;
147         if (i)
148             put_bits(&a->pb, ff_asv_ac_ccp_tab[ccp][1], ff_asv_ac_ccp_tab[ccp][0]);
149         else
150             put_bits(&a->pb, ff_asv_dc_ccp_tab[ccp][1], ff_asv_dc_ccp_tab[ccp][0]);
151
152         if (ccp) {
153             if (ccp & 8)
154                 asv2_put_level(&a->pb, block[index + 0]);
155             if (ccp & 4)
156                 asv2_put_level(&a->pb, block[index + 8]);
157             if (ccp & 2)
158                 asv2_put_level(&a->pb, block[index + 1]);
159             if (ccp & 1)
160                 asv2_put_level(&a->pb, block[index + 9]);
161         }
162     }
163
164     return 0;
165 }
166
167 #define MAX_MB_SIZE (30 * 16 * 16 * 3 / 2 / 8)
168
169 static inline int encode_mb(ASV1Context *a, int16_t block[6][64])
170 {
171     int i, ret;
172
173     if (a->pb.buf_end - a->pb.buf - (put_bits_count(&a->pb) >> 3) < MAX_MB_SIZE) {
174         av_log(a->avctx, AV_LOG_ERROR, "encoded frame too large\n");
175         return -1;
176     }
177
178     if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
179         for (i = 0; i < 6; i++)
180             asv1_encode_block(a, block[i]);
181     } else {
182         for (i = 0; i < 6; i++) {
183             ret = asv2_encode_block(a, block[i]);
184             if (ret < 0)
185                 return ret;
186         }
187     }
188     return 0;
189 }
190
191 static inline void dct_get(ASV1Context *a, const AVFrame *frame,
192                            int mb_x, int mb_y)
193 {
194     int16_t (*block)[64] = a->block;
195     int linesize = frame->linesize[0];
196     int i;
197
198     uint8_t *ptr_y  = frame->data[0] + (mb_y * 16 * linesize)           + mb_x * 16;
199     uint8_t *ptr_cb = frame->data[1] + (mb_y *  8 * frame->linesize[1]) + mb_x *  8;
200     uint8_t *ptr_cr = frame->data[2] + (mb_y *  8 * frame->linesize[2]) + mb_x *  8;
201
202     a->pdsp.get_pixels(block[0], ptr_y,                    linesize);
203     a->pdsp.get_pixels(block[1], ptr_y + 8,                linesize);
204     a->pdsp.get_pixels(block[2], ptr_y + 8 * linesize,     linesize);
205     a->pdsp.get_pixels(block[3], ptr_y + 8 * linesize + 8, linesize);
206     for (i = 0; i < 4; i++)
207         a->fdsp.fdct(block[i]);
208
209     if (!(a->avctx->flags & CODEC_FLAG_GRAY)) {
210         a->pdsp.get_pixels(block[4], ptr_cb, frame->linesize[1]);
211         a->pdsp.get_pixels(block[5], ptr_cr, frame->linesize[2]);
212         for (i = 4; i < 6; i++)
213             a->fdsp.fdct(block[i]);
214     }
215 }
216
217 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
218                         const AVFrame *pict, int *got_packet)
219 {
220     ASV1Context *const a = avctx->priv_data;
221     int size, ret;
222     int mb_x, mb_y;
223
224     if (!pkt->data &&
225         (ret = av_new_packet(pkt, a->mb_height * a->mb_width * MAX_MB_SIZE +
226                              FF_MIN_BUFFER_SIZE)) < 0) {
227         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
228         return ret;
229     }
230
231     init_put_bits(&a->pb, pkt->data, pkt->size);
232
233     for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
234         for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
235             dct_get(a, pict, mb_x, mb_y);
236             encode_mb(a, a->block);
237         }
238     }
239
240     if (a->mb_width2 != a->mb_width) {
241         mb_x = a->mb_width2;
242         for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
243             dct_get(a, pict, mb_x, mb_y);
244             encode_mb(a, a->block);
245         }
246     }
247
248     if (a->mb_height2 != a->mb_height) {
249         mb_y = a->mb_height2;
250         for (mb_x = 0; mb_x < a->mb_width; mb_x++) {
251             dct_get(a, pict, mb_x, mb_y);
252             encode_mb(a, a->block);
253         }
254     }
255     emms_c();
256
257     avpriv_align_put_bits(&a->pb);
258     while (put_bits_count(&a->pb) & 31)
259         put_bits(&a->pb, 8, 0);
260
261     size = put_bits_count(&a->pb) / 32;
262
263     if (avctx->codec_id == AV_CODEC_ID_ASV1) {
264         a->bbdsp.bswap_buf((uint32_t *) pkt->data,
265                            (uint32_t *) pkt->data, size);
266     } else {
267         int i;
268         for (i = 0; i < 4 * size; i++)
269             pkt->data[i] = ff_reverse[pkt->data[i]];
270     }
271
272     pkt->size   = size * 4;
273     pkt->flags |= AV_PKT_FLAG_KEY;
274     *got_packet = 1;
275
276     return 0;
277 }
278
279 static av_cold int encode_init(AVCodecContext *avctx)
280 {
281     ASV1Context *const a = avctx->priv_data;
282     int i;
283     const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
284
285     avctx->coded_frame = av_frame_alloc();
286     if (!avctx->coded_frame)
287         return AVERROR(ENOMEM);
288     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
289     avctx->coded_frame->key_frame = 1;
290
291     ff_asv_common_init(avctx);
292     ff_fdctdsp_init(&a->fdsp, avctx);
293     ff_pixblockdsp_init(&a->pdsp, avctx);
294
295     if (avctx->global_quality == 0)
296         avctx->global_quality = 4 * FF_QUALITY_SCALE;
297
298     a->inv_qscale = (32 * scale * FF_QUALITY_SCALE +
299                      avctx->global_quality / 2) / avctx->global_quality;
300
301     avctx->extradata                   = av_mallocz(8);
302     if (!avctx->extradata)
303         return AVERROR(ENOMEM);
304     avctx->extradata_size              = 8;
305     ((uint32_t *) avctx->extradata)[0] = av_le2ne32(a->inv_qscale);
306     ((uint32_t *) avctx->extradata)[1] = av_le2ne32(AV_RL32("ASUS"));
307
308     for (i = 0; i < 64; i++) {
309         int q = 32 * scale * ff_mpeg1_default_intra_matrix[i];
310         a->q_intra_matrix[i] = ((a->inv_qscale << 16) + q / 2) / q;
311     }
312
313     return 0;
314 }
315
316 static av_cold int asv_encode_close(AVCodecContext *avctx)
317 {
318     av_frame_free(&avctx->coded_frame);
319
320     return 0;
321 }
322
323 #if CONFIG_ASV1_ENCODER
324 AVCodec ff_asv1_encoder = {
325     .name           = "asv1",
326     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),
327     .type           = AVMEDIA_TYPE_VIDEO,
328     .id             = AV_CODEC_ID_ASV1,
329     .priv_data_size = sizeof(ASV1Context),
330     .init           = encode_init,
331     .encode2        = encode_frame,
332     .close          = asv_encode_close,
333     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
334                                                      AV_PIX_FMT_NONE },
335     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
336                       FF_CODEC_CAP_INIT_CLEANUP,
337 };
338 #endif
339
340 #if CONFIG_ASV2_ENCODER
341 AVCodec ff_asv2_encoder = {
342     .name           = "asv2",
343     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),
344     .type           = AVMEDIA_TYPE_VIDEO,
345     .id             = AV_CODEC_ID_ASV2,
346     .priv_data_size = sizeof(ASV1Context),
347     .init           = encode_init,
348     .encode2        = encode_frame,
349     .close          = asv_encode_close,
350     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
351                                                      AV_PIX_FMT_NONE },
352     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
353                       FF_CODEC_CAP_INIT_CLEANUP,
354 };
355 #endif