2 * Copyright (c) 2003 Michael Niedermayer
4 * This file is part of FFmpeg.
6 * FFmpeg 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.
11 * FFmpeg 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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavutil/attributes.h"
27 #include "libavutil/mem.h"
29 #include "aandcttab.h"
36 #include "mpeg12data.h"
38 static inline void asv2_put_bits(PutBitContext
*pb
, int n
, int v
)
40 put_bits(pb
, n
, ff_reverse
[v
<< (8 - n
)]);
43 static inline void asv1_put_level(PutBitContext
*pb
, int level
)
45 unsigned int index
= level
+ 3;
48 put_bits(pb
, ff_asv_level_tab
[index
][1], ff_asv_level_tab
[index
][0]);
50 put_bits(pb
, ff_asv_level_tab
[3][1], ff_asv_level_tab
[3][0]);
51 put_sbits(pb
, 8, level
);
55 static inline void asv2_put_level(ASV1Context
*a
, PutBitContext
*pb
, int level
)
57 unsigned int index
= level
+ 31;
60 put_bits(pb
, ff_asv2_level_tab
[index
][1], ff_asv2_level_tab
[index
][0]);
62 put_bits(pb
, ff_asv2_level_tab
[31][1], ff_asv2_level_tab
[31][0]);
63 if (level
< -128 || level
> 127) {
64 av_log(a
->avctx
, AV_LOG_WARNING
, "Cliping level %d, increase qscale\n", level
);
65 level
= av_clip_int8(level
);
67 asv2_put_bits(pb
, 8, level
& 0xFF);
71 static inline void asv1_encode_block(ASV1Context
*a
, int16_t block
[64])
76 put_bits(&a
->pb
, 8, (block
[0] + 32) >> 6);
79 for (i
= 0; i
< 10; i
++) {
80 const int index
= ff_asv_scantab
[4 * i
];
83 if ((block
[index
+ 0] = (block
[index
+ 0] *
84 a
->q_intra_matrix
[index
+ 0] + (1 << 15)) >> 16))
86 if ((block
[index
+ 8] = (block
[index
+ 8] *
87 a
->q_intra_matrix
[index
+ 8] + (1 << 15)) >> 16))
89 if ((block
[index
+ 1] = (block
[index
+ 1] *
90 a
->q_intra_matrix
[index
+ 1] + (1 << 15)) >> 16))
92 if ((block
[index
+ 9] = (block
[index
+ 9] *
93 a
->q_intra_matrix
[index
+ 9] + (1 << 15)) >> 16))
97 for (; nc_count
; nc_count
--)
98 put_bits(&a
->pb
, ff_asv_ccp_tab
[0][1], ff_asv_ccp_tab
[0][0]);
100 put_bits(&a
->pb
, ff_asv_ccp_tab
[ccp
][1], ff_asv_ccp_tab
[ccp
][0]);
103 asv1_put_level(&a
->pb
, block
[index
+ 0]);
105 asv1_put_level(&a
->pb
, block
[index
+ 8]);
107 asv1_put_level(&a
->pb
, block
[index
+ 1]);
109 asv1_put_level(&a
->pb
, block
[index
+ 9]);
114 put_bits(&a
->pb
, ff_asv_ccp_tab
[16][1], ff_asv_ccp_tab
[16][0]);
117 static inline void asv2_encode_block(ASV1Context
*a
, int16_t block
[64])
122 for (count
= 63; count
> 3; count
--) {
123 const int index
= ff_asv_scantab
[count
];
124 if ((block
[index
] * a
->q_intra_matrix
[index
] + (1 << 15)) >> 16)
130 asv2_put_bits(&a
->pb
, 4, count
);
131 asv2_put_bits(&a
->pb
, 8, (block
[0] + 32) >> 6);
134 for (i
= 0; i
<= count
; i
++) {
135 const int index
= ff_asv_scantab
[4 * i
];
138 if ((block
[index
+ 0] = (block
[index
+ 0] *
139 a
->q_intra_matrix
[index
+ 0] + (1 << 15)) >> 16))
141 if ((block
[index
+ 8] = (block
[index
+ 8] *
142 a
->q_intra_matrix
[index
+ 8] + (1 << 15)) >> 16))
144 if ((block
[index
+ 1] = (block
[index
+ 1] *
145 a
->q_intra_matrix
[index
+ 1] + (1 << 15)) >> 16))
147 if ((block
[index
+ 9] = (block
[index
+ 9] *
148 a
->q_intra_matrix
[index
+ 9] + (1 << 15)) >> 16))
151 av_assert2(i
|| ccp
< 8);
153 put_bits(&a
->pb
, ff_asv_ac_ccp_tab
[ccp
][1], ff_asv_ac_ccp_tab
[ccp
][0]);
155 put_bits(&a
->pb
, ff_asv_dc_ccp_tab
[ccp
][1], ff_asv_dc_ccp_tab
[ccp
][0]);
159 asv2_put_level(a
, &a
->pb
, block
[index
+ 0]);
161 asv2_put_level(a
, &a
->pb
, block
[index
+ 8]);
163 asv2_put_level(a
, &a
->pb
, block
[index
+ 1]);
165 asv2_put_level(a
, &a
->pb
, block
[index
+ 9]);
170 #define MAX_MB_SIZE (30 * 16 * 16 * 3 / 2 / 8)
172 static inline int encode_mb(ASV1Context
*a
, int16_t block
[6][64])
176 if (a
->pb
.buf_end
- a
->pb
.buf
- (put_bits_count(&a
->pb
) >> 3) < MAX_MB_SIZE
) {
177 av_log(a
->avctx
, AV_LOG_ERROR
, "encoded frame too large\n");
181 if (a
->avctx
->codec_id
== AV_CODEC_ID_ASV1
) {
182 for (i
= 0; i
< 6; i
++)
183 asv1_encode_block(a
, block
[i
]);
185 for (i
= 0; i
< 6; i
++)
186 asv2_encode_block(a
, block
[i
]);
191 static inline void dct_get(ASV1Context
*a
, const AVFrame
*frame
,
194 int16_t (*block
)[64] = a
->block
;
195 int linesize
= frame
->linesize
[0];
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;
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
]);
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
]);
217 static int encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
218 const AVFrame
*pict
, int *got_packet
)
220 ASV1Context
*const a
= avctx
->priv_data
;
224 if (pict
->width
% 16 || pict
->height
% 16) {
225 AVFrame
*clone
= av_frame_alloc();
229 return AVERROR(ENOMEM
);
230 clone
->format
= pict
->format
;
231 clone
->width
= FFALIGN(pict
->width
, 16);
232 clone
->height
= FFALIGN(pict
->height
, 16);
233 ret
= av_frame_get_buffer(clone
, 32);
235 av_frame_free(&clone
);
239 ret
= av_frame_copy(clone
, pict
);
241 av_frame_free(&clone
);
245 for (i
= 0; i
<3; i
++) {
247 int w
= FF_CEIL_RSHIFT(pict
->width
, !!i
);
248 int h
= FF_CEIL_RSHIFT(pict
->height
, !!i
);
249 int w2
= FF_CEIL_RSHIFT(clone
->width
, !!i
);
250 int h2
= FF_CEIL_RSHIFT(clone
->height
, !!i
);
253 clone
->data
[i
][x
+ y
*clone
->linesize
[i
]] =
254 clone
->data
[i
][w
- 1 + y
*clone
->linesize
[i
]];
257 clone
->data
[i
][x
+ y
*clone
->linesize
[i
]] =
258 clone
->data
[i
][x
+ (h
-1)*clone
->linesize
[i
]];
260 ret
= encode_frame(avctx
, pkt
, clone
, got_packet
);
262 av_frame_free(&clone
);
266 if ((ret
= ff_alloc_packet2(avctx
, pkt
, a
->mb_height
* a
->mb_width
* MAX_MB_SIZE
+
267 FF_MIN_BUFFER_SIZE
)) < 0)
270 init_put_bits(&a
->pb
, pkt
->data
, pkt
->size
);
272 for (mb_y
= 0; mb_y
< a
->mb_height2
; mb_y
++) {
273 for (mb_x
= 0; mb_x
< a
->mb_width2
; mb_x
++) {
274 dct_get(a
, pict
, mb_x
, mb_y
);
275 encode_mb(a
, a
->block
);
279 if (a
->mb_width2
!= a
->mb_width
) {
281 for (mb_y
= 0; mb_y
< a
->mb_height2
; mb_y
++) {
282 dct_get(a
, pict
, mb_x
, mb_y
);
283 encode_mb(a
, a
->block
);
287 if (a
->mb_height2
!= a
->mb_height
) {
288 mb_y
= a
->mb_height2
;
289 for (mb_x
= 0; mb_x
< a
->mb_width
; mb_x
++) {
290 dct_get(a
, pict
, mb_x
, mb_y
);
291 encode_mb(a
, a
->block
);
296 avpriv_align_put_bits(&a
->pb
);
297 while (put_bits_count(&a
->pb
) & 31)
298 put_bits(&a
->pb
, 8, 0);
300 size
= put_bits_count(&a
->pb
) / 32;
302 if (avctx
->codec_id
== AV_CODEC_ID_ASV1
) {
303 a
->bbdsp
.bswap_buf((uint32_t *) pkt
->data
,
304 (uint32_t *) pkt
->data
, size
);
307 for (i
= 0; i
< 4 * size
; i
++)
308 pkt
->data
[i
] = ff_reverse
[pkt
->data
[i
]];
311 pkt
->size
= size
* 4;
312 pkt
->flags
|= AV_PKT_FLAG_KEY
;
318 static av_cold
int encode_init(AVCodecContext
*avctx
)
320 ASV1Context
*const a
= avctx
->priv_data
;
322 const int scale
= avctx
->codec_id
== AV_CODEC_ID_ASV1
? 1 : 2;
324 ff_asv_common_init(avctx
);
325 ff_fdctdsp_init(&a
->fdsp
, avctx
);
326 ff_pixblockdsp_init(&a
->pdsp
, avctx
);
328 if (avctx
->global_quality
<= 0)
329 avctx
->global_quality
= 4 * FF_QUALITY_SCALE
;
331 a
->inv_qscale
= (32 * scale
* FF_QUALITY_SCALE
+
332 avctx
->global_quality
/ 2) / avctx
->global_quality
;
334 avctx
->extradata
= av_mallocz(8);
335 avctx
->extradata_size
= 8;
336 ((uint32_t *) avctx
->extradata
)[0] = av_le2ne32(a
->inv_qscale
);
337 ((uint32_t *) avctx
->extradata
)[1] = av_le2ne32(AV_RL32("ASUS"));
339 for (i
= 0; i
< 64; i
++) {
340 if (a
->fdsp
.fdct
== ff_fdct_ifast
) {
341 int q
= 32LL * scale
* ff_mpeg1_default_intra_matrix
[i
] * ff_aanscales
[i
];
342 a
->q_intra_matrix
[i
] = (((int64_t)a
->inv_qscale
<< 30) + q
/ 2) / q
;
344 int q
= 32 * scale
* ff_mpeg1_default_intra_matrix
[i
];
345 a
->q_intra_matrix
[i
] = ((a
->inv_qscale
<< 16) + q
/ 2) / q
;
352 #if CONFIG_ASV1_ENCODER
353 AVCodec ff_asv1_encoder
= {
355 .long_name
= NULL_IF_CONFIG_SMALL("ASUS V1"),
356 .type
= AVMEDIA_TYPE_VIDEO
,
357 .id
= AV_CODEC_ID_ASV1
,
358 .priv_data_size
= sizeof(ASV1Context
),
360 .encode2
= encode_frame
,
361 .pix_fmts
= (const enum AVPixelFormat
[]) { AV_PIX_FMT_YUV420P
,
366 #if CONFIG_ASV2_ENCODER
367 AVCodec ff_asv2_encoder
= {
369 .long_name
= NULL_IF_CONFIG_SMALL("ASUS V2"),
370 .type
= AVMEDIA_TYPE_VIDEO
,
371 .id
= AV_CODEC_ID_ASV2
,
372 .priv_data_size
= sizeof(ASV1Context
),
374 .encode2
= encode_frame
,
375 .pix_fmts
= (const enum AVPixelFormat
[]) { AV_PIX_FMT_YUV420P
,