hwaccel: OS X Video Decoder Acceleration (VDA) support.
[libav.git] / libavcodec / mpegvideo.c
1 /*
2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7 *
8 * This file is part of Libav.
9 *
10 * Libav is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * Libav is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with Libav; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /**
26 * @file
27 * The simplest mpeg encoder (well, it was the simplest!).
28 */
29
30 #include "libavutil/intmath.h"
31 #include "libavutil/imgutils.h"
32 #include "avcodec.h"
33 #include "dsputil.h"
34 #include "internal.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
37 #include "mjpegenc.h"
38 #include "msmpeg4.h"
39 #include "faandct.h"
40 #include "xvmc_internal.h"
41 #include "thread.h"
42 #include <limits.h>
43
44 //#undef NDEBUG
45 //#include <assert.h>
46
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58 DCTELEM *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60 DCTELEM *block, int n, int qscale);
61
62
63 /* enable all paranoid tests for rounding, overflows, etc... */
64 //#define PARANOID
65
66 //#define DEBUG
67
68
69 static const uint8_t ff_default_chroma_qscale_table[32]={
70 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
71 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
72 };
73
74 const uint8_t ff_mpeg1_dc_scale_table[128]={
75 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
76 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
80 };
81
82 static const uint8_t mpeg2_dc_scale_table1[128]={
83 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
84 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88 };
89
90 static const uint8_t mpeg2_dc_scale_table2[128]={
91 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
92 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
96 };
97
98 static const uint8_t mpeg2_dc_scale_table3[128]={
99 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
100 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
102 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
103 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
104 };
105
106 const uint8_t * const ff_mpeg2_dc_scale_table[4]={
107 ff_mpeg1_dc_scale_table,
108 mpeg2_dc_scale_table1,
109 mpeg2_dc_scale_table2,
110 mpeg2_dc_scale_table3,
111 };
112
113 const enum PixelFormat ff_pixfmt_list_420[] = {
114 PIX_FMT_YUV420P,
115 PIX_FMT_NONE
116 };
117
118 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
119 PIX_FMT_DXVA2_VLD,
120 PIX_FMT_VAAPI_VLD,
121 PIX_FMT_VDA_VLD,
122 PIX_FMT_YUV420P,
123 PIX_FMT_NONE
124 };
125
126 const uint8_t *avpriv_mpv_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
127 int i;
128
129 assert(p<=end);
130 if(p>=end)
131 return end;
132
133 for(i=0; i<3; i++){
134 uint32_t tmp= *state << 8;
135 *state= tmp + *(p++);
136 if(tmp == 0x100 || p==end)
137 return p;
138 }
139
140 while(p<end){
141 if (p[-1] > 1 ) p+= 3;
142 else if(p[-2] ) p+= 2;
143 else if(p[-3]|(p[-1]-1)) p++;
144 else{
145 p++;
146 break;
147 }
148 }
149
150 p= FFMIN(p, end)-4;
151 *state= AV_RB32(p);
152
153 return p+4;
154 }
155
156 /* init common dct for both encoder and decoder */
157 av_cold int ff_dct_common_init(MpegEncContext *s)
158 {
159 dsputil_init(&s->dsp, s->avctx);
160
161 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
162 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
163 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
164 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
165 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
166 if(s->flags & CODEC_FLAG_BITEXACT)
167 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
168 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
169
170 #if HAVE_MMX
171 MPV_common_init_mmx(s);
172 #elif ARCH_ALPHA
173 MPV_common_init_axp(s);
174 #elif CONFIG_MLIB
175 MPV_common_init_mlib(s);
176 #elif HAVE_MMI
177 MPV_common_init_mmi(s);
178 #elif ARCH_ARM
179 MPV_common_init_arm(s);
180 #elif HAVE_ALTIVEC
181 MPV_common_init_altivec(s);
182 #elif ARCH_BFIN
183 MPV_common_init_bfin(s);
184 #endif
185
186 /* load & permutate scantables
187 note: only wmv uses different ones
188 */
189 if(s->alternate_scan){
190 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
191 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
192 }else{
193 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
194 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
195 }
196 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
197 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
198
199 return 0;
200 }
201
202 void ff_copy_picture(Picture *dst, Picture *src){
203 *dst = *src;
204 dst->f.type= FF_BUFFER_TYPE_COPY;
205 }
206
207 /**
208 * Release a frame buffer
209 */
210 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
211 {
212 /* Windows Media Image codecs allocate internal buffers with different
213 dimensions; ignore user defined callbacks for these */
214 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
215 ff_thread_release_buffer(s->avctx, (AVFrame*)pic);
216 else
217 avcodec_default_release_buffer(s->avctx, (AVFrame*)pic);
218 av_freep(&pic->f.hwaccel_picture_private);
219 }
220
221 /**
222 * Allocate a frame buffer
223 */
224 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
225 {
226 int r;
227
228 if (s->avctx->hwaccel) {
229 assert(!pic->f.hwaccel_picture_private);
230 if (s->avctx->hwaccel->priv_data_size) {
231 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
232 if (!pic->f.hwaccel_picture_private) {
233 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
234 return -1;
235 }
236 }
237 }
238
239 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
240 r = ff_thread_get_buffer(s->avctx, (AVFrame*)pic);
241 else
242 r = avcodec_default_get_buffer(s->avctx, (AVFrame*)pic);
243
244 if (r < 0 || !pic->f.age || !pic->f.type || !pic->f.data[0]) {
245 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n",
246 r, pic->f.age, pic->f.type, pic->f.data[0]);
247 av_freep(&pic->f.hwaccel_picture_private);
248 return -1;
249 }
250
251 if (s->linesize && (s->linesize != pic->f.linesize[0] || s->uvlinesize != pic->f.linesize[1])) {
252 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
253 free_frame_buffer(s, pic);
254 return -1;
255 }
256
257 if (pic->f.linesize[1] != pic->f.linesize[2]) {
258 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
259 free_frame_buffer(s, pic);
260 return -1;
261 }
262
263 return 0;
264 }
265
266 /**
267 * allocates a Picture
268 * The pixels are allocated/set by calling get_buffer() if shared=0
269 */
270 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
271 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
272 const int mb_array_size= s->mb_stride*s->mb_height;
273 const int b8_array_size= s->b8_stride*s->mb_height*2;
274 const int b4_array_size= s->b4_stride*s->mb_height*4;
275 int i;
276 int r= -1;
277
278 if(shared){
279 assert(pic->f.data[0]);
280 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
281 pic->f.type = FF_BUFFER_TYPE_SHARED;
282 }else{
283 assert(!pic->f.data[0]);
284
285 if (alloc_frame_buffer(s, pic) < 0)
286 return -1;
287
288 s->linesize = pic->f.linesize[0];
289 s->uvlinesize = pic->f.linesize[1];
290 }
291
292 if (pic->f.qscale_table == NULL) {
293 if (s->encoding) {
294 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var , mb_array_size * sizeof(int16_t) , fail)
295 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var, mb_array_size * sizeof(int16_t) , fail)
296 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean , mb_array_size * sizeof(int8_t ) , fail)
297 }
298
299 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table, mb_array_size * sizeof(uint8_t) + 2, fail) //the +2 is for the slice end check
300 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base , (big_mb_num + s->mb_stride) * sizeof(uint8_t) , fail)
301 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t), fail)
302 pic->f.mb_type = pic->mb_type_base + 2*s->mb_stride + 1;
303 pic->f.qscale_table = pic->qscale_table_base + 2*s->mb_stride + 1;
304 if(s->out_format == FMT_H264){
305 for(i=0; i<2; i++){
306 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t), fail)
307 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
308 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
309 }
310 pic->f.motion_subsample_log2 = 2;
311 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
312 for(i=0; i<2; i++){
313 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
314 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
315 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
316 }
317 pic->f.motion_subsample_log2 = 3;
318 }
319 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
320 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff, 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
321 }
322 pic->f.qstride = s->mb_stride;
323 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan , 1 * sizeof(AVPanScan), fail)
324 }
325
326 /* It might be nicer if the application would keep track of these
327 * but it would require an API change. */
328 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
329 s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
330 if (pic->f.age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->f.age] == AV_PICTURE_TYPE_B)
331 pic->f.age = INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
332 pic->owner2 = s;
333
334 return 0;
335 fail: //for the FF_ALLOCZ_OR_GOTO macro
336 if(r>=0)
337 free_frame_buffer(s, pic);
338 return -1;
339 }
340
341 /**
342 * deallocates a picture
343 */
344 static void free_picture(MpegEncContext *s, Picture *pic){
345 int i;
346
347 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
348 free_frame_buffer(s, pic);
349 }
350
351 av_freep(&pic->mb_var);
352 av_freep(&pic->mc_mb_var);
353 av_freep(&pic->mb_mean);
354 av_freep(&pic->f.mbskip_table);
355 av_freep(&pic->qscale_table_base);
356 av_freep(&pic->mb_type_base);
357 av_freep(&pic->f.dct_coeff);
358 av_freep(&pic->f.pan_scan);
359 pic->f.mb_type = NULL;
360 for(i=0; i<2; i++){
361 av_freep(&pic->motion_val_base[i]);
362 av_freep(&pic->f.ref_index[i]);
363 }
364
365 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
366 for(i=0; i<4; i++){
367 pic->f.base[i] =
368 pic->f.data[i] = NULL;
369 }
370 pic->f.type = 0;
371 }
372 }
373
374 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
375 int y_size = s->b8_stride * (2 * s->mb_height + 1);
376 int c_size = s->mb_stride * (s->mb_height + 1);
377 int yc_size = y_size + 2 * c_size;
378 int i;
379
380 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
381 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, (s->width+64)*2*21*2, fail); //(width + edge + align)*interlaced*MBsize*tolerance
382
383 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
384 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t), fail)
385 s->me.temp= s->me.scratchpad;
386 s->rd_scratchpad= s->me.scratchpad;
387 s->b_scratchpad= s->me.scratchpad;
388 s->obmc_scratchpad= s->me.scratchpad + 16;
389 if (s->encoding) {
390 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map , ME_MAP_SIZE*sizeof(uint32_t), fail)
391 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
392 if(s->avctx->noise_reduction){
393 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
394 }
395 }
396 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
397 s->block= s->blocks[0];
398
399 for(i=0;i<12;i++){
400 s->pblocks[i] = &s->block[i];
401 }
402
403 if (s->out_format == FMT_H263) {
404 /* ac values */
405 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
406 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
407 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
408 s->ac_val[2] = s->ac_val[1] + c_size;
409 }
410
411 return 0;
412 fail:
413 return -1; //free() through MPV_common_end()
414 }
415
416 static void free_duplicate_context(MpegEncContext *s){
417 if(s==NULL) return;
418
419 av_freep(&s->edge_emu_buffer);
420 av_freep(&s->me.scratchpad);
421 s->me.temp=
422 s->rd_scratchpad=
423 s->b_scratchpad=
424 s->obmc_scratchpad= NULL;
425
426 av_freep(&s->dct_error_sum);
427 av_freep(&s->me.map);
428 av_freep(&s->me.score_map);
429 av_freep(&s->blocks);
430 av_freep(&s->ac_val_base);
431 s->block= NULL;
432 }
433
434 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
435 #define COPY(a) bak->a= src->a
436 COPY(edge_emu_buffer);
437 COPY(me.scratchpad);
438 COPY(me.temp);
439 COPY(rd_scratchpad);
440 COPY(b_scratchpad);
441 COPY(obmc_scratchpad);
442 COPY(me.map);
443 COPY(me.score_map);
444 COPY(blocks);
445 COPY(block);
446 COPY(start_mb_y);
447 COPY(end_mb_y);
448 COPY(me.map_generation);
449 COPY(pb);
450 COPY(dct_error_sum);
451 COPY(dct_count[0]);
452 COPY(dct_count[1]);
453 COPY(ac_val_base);
454 COPY(ac_val[0]);
455 COPY(ac_val[1]);
456 COPY(ac_val[2]);
457 #undef COPY
458 }
459
460 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
461 MpegEncContext bak;
462 int i;
463 //FIXME copy only needed parts
464 //START_TIMER
465 backup_duplicate_context(&bak, dst);
466 memcpy(dst, src, sizeof(MpegEncContext));
467 backup_duplicate_context(dst, &bak);
468 for(i=0;i<12;i++){
469 dst->pblocks[i] = &dst->block[i];
470 }
471 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
472 }
473
474 int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
475 {
476 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
477
478 if(dst == src || !s1->context_initialized) return 0;
479
480 //FIXME can parameters change on I-frames? in that case dst may need a reinit
481 if(!s->context_initialized){
482 memcpy(s, s1, sizeof(MpegEncContext));
483
484 s->avctx = dst;
485 s->picture_range_start += MAX_PICTURE_COUNT;
486 s->picture_range_end += MAX_PICTURE_COUNT;
487 s->bitstream_buffer = NULL;
488 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
489
490 MPV_common_init(s);
491 }
492
493 s->avctx->coded_height = s1->avctx->coded_height;
494 s->avctx->coded_width = s1->avctx->coded_width;
495 s->avctx->width = s1->avctx->width;
496 s->avctx->height = s1->avctx->height;
497
498 s->coded_picture_number = s1->coded_picture_number;
499 s->picture_number = s1->picture_number;
500 s->input_picture_number = s1->input_picture_number;
501
502 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
503 memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
504
505 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
506 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
507 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
508
509 memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
510
511 //Error/bug resilience
512 s->next_p_frame_damaged = s1->next_p_frame_damaged;
513 s->workaround_bugs = s1->workaround_bugs;
514
515 //MPEG4 timing info
516 memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
517
518 //B-frame info
519 s->max_b_frames = s1->max_b_frames;
520 s->low_delay = s1->low_delay;
521 s->dropable = s1->dropable;
522
523 //DivX handling (doesn't work)
524 s->divx_packed = s1->divx_packed;
525
526 if(s1->bitstream_buffer){
527 if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
528 av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
529 s->bitstream_buffer_size = s1->bitstream_buffer_size;
530 memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
531 memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
532 }
533
534 //MPEG2/interlacing info
535 memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
536
537 if(!s1->first_field){
538 s->last_pict_type= s1->pict_type;
539 if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
540
541 if (s1->pict_type != AV_PICTURE_TYPE_B) {
542 s->last_non_b_pict_type= s1->pict_type;
543 }
544 }
545
546 return 0;
547 }
548
549 /**
550 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
551 * the changed fields will not depend upon the prior state of the MpegEncContext.
552 */
553 void MPV_common_defaults(MpegEncContext *s){
554 s->y_dc_scale_table=
555 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
556 s->chroma_qscale_table= ff_default_chroma_qscale_table;
557 s->progressive_frame= 1;
558 s->progressive_sequence= 1;
559 s->picture_structure= PICT_FRAME;
560
561 s->coded_picture_number = 0;
562 s->picture_number = 0;
563 s->input_picture_number = 0;
564
565 s->picture_in_gop_number = 0;
566
567 s->f_code = 1;
568 s->b_code = 1;
569
570 s->picture_range_start = 0;
571 s->picture_range_end = MAX_PICTURE_COUNT;
572 }
573
574 /**
575 * sets the given MpegEncContext to defaults for decoding.
576 * the changed fields will not depend upon the prior state of the MpegEncContext.
577 */
578 void MPV_decode_defaults(MpegEncContext *s){
579 MPV_common_defaults(s);
580 }
581
582 /**
583 * init common structure for both encoder and decoder.
584 * this assumes that some variables like width/height are already set
585 */
586 av_cold int MPV_common_init(MpegEncContext *s)
587 {
588 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y,
589 threads = (s->encoding ||
590 (HAVE_THREADS &&
591 s->avctx->active_thread_type & FF_THREAD_SLICE)) ?
592 s->avctx->thread_count : 1;
593
594 if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
595 s->mb_height = (s->height + 31) / 32 * 2;
596 else if (s->codec_id != CODEC_ID_H264)
597 s->mb_height = (s->height + 15) / 16;
598
599 if(s->avctx->pix_fmt == PIX_FMT_NONE){
600 av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
601 return -1;
602 }
603
604 if((s->encoding || (s->avctx->active_thread_type & FF_THREAD_SLICE)) &&
605 (s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
606 int max_threads = FFMIN(MAX_THREADS, s->mb_height);
607 av_log(s->avctx, AV_LOG_WARNING, "too many threads (%d), reducing to %d\n",
608 s->avctx->thread_count, max_threads);
609 threads = max_threads;
610 }
611
612 if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
613 return -1;
614
615 ff_dct_common_init(s);
616
617 s->flags= s->avctx->flags;
618 s->flags2= s->avctx->flags2;
619
620 if (s->width && s->height) {
621 s->mb_width = (s->width + 15) / 16;
622 s->mb_stride = s->mb_width + 1;
623 s->b8_stride = s->mb_width*2 + 1;
624 s->b4_stride = s->mb_width*4 + 1;
625 mb_array_size= s->mb_height * s->mb_stride;
626 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
627
628 /* set chroma shifts */
629 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
630 &(s->chroma_y_shift) );
631
632 /* set default edge pos, will be overriden in decode_header if needed */
633 s->h_edge_pos= s->mb_width*16;
634 s->v_edge_pos= s->mb_height*16;
635
636 s->mb_num = s->mb_width * s->mb_height;
637
638 s->block_wrap[0]=
639 s->block_wrap[1]=
640 s->block_wrap[2]=
641 s->block_wrap[3]= s->b8_stride;
642 s->block_wrap[4]=
643 s->block_wrap[5]= s->mb_stride;
644
645 y_size = s->b8_stride * (2 * s->mb_height + 1);
646 c_size = s->mb_stride * (s->mb_height + 1);
647 yc_size = y_size + 2 * c_size;
648
649 /* convert fourcc to upper case */
650 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
651
652 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
653
654 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
655
656 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
657 for(y=0; y<s->mb_height; y++){
658 for(x=0; x<s->mb_width; x++){
659 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
660 }
661 }
662 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
663
664 if (s->encoding) {
665 /* Allocate MV tables */
666 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
667 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
668 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
669 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
670 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
671 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
672 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
673 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
674 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
675 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
676 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
677 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
678
679 if(s->msmpeg4_version){
680 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
681 }
682 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
683
684 /* Allocate MB type table */
685 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
686
687 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
688
689 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
690 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
691 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
692 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
693 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
694 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
695
696 if(s->avctx->noise_reduction){
697 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
698 }
699 }
700 }
701
702 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
703 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
704 for(i = 0; i < s->picture_count; i++) {
705 avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
706 }
707
708 if (s->width && s->height) {
709 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
710
711 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
712 /* interlaced direct mode decoding tables */
713 for(i=0; i<2; i++){
714 int j, k;
715 for(j=0; j<2; j++){
716 for(k=0; k<2; k++){
717 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
718 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
719 }
720 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
721 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
722 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
723 }
724 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
725 }
726 }
727 if (s->out_format == FMT_H263) {
728 /* cbp values */
729 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
730 s->coded_block= s->coded_block_base + s->b8_stride + 1;
731
732 /* cbp, ac_pred, pred_dir */
733 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail)
734 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
735 }
736
737 if (s->h263_pred || s->h263_plus || !s->encoding) {
738 /* dc values */
739 //MN: we need these for error resilience of intra-frames
740 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
741 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
742 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
743 s->dc_val[2] = s->dc_val[1] + c_size;
744 for(i=0;i<yc_size;i++)
745 s->dc_val_base[i] = 1024;
746 }
747
748 /* which mb is a intra block */
749 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
750 memset(s->mbintra_table, 1, mb_array_size);
751
752 /* init macroblock skip table */
753 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
754 //Note the +1 is for a quicker mpeg4 slice_end detection
755 FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
756
757 s->parse_context.state= -1;
758 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
759 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
760 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
761 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
762 }
763 }
764
765 s->context_initialized = 1;
766 s->thread_context[0]= s;
767
768 if (s->width && s->height) {
769 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
770 for(i=1; i<threads; i++){
771 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
772 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
773 }
774
775 for(i=0; i<threads; i++){
776 if(init_duplicate_context(s->thread_context[i], s) < 0)
777 goto fail;
778 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
779 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
780 }
781 } else {
782 if(init_duplicate_context(s, s) < 0) goto fail;
783 s->start_mb_y = 0;
784 s->end_mb_y = s->mb_height;
785 }
786 }
787
788 return 0;
789 fail:
790 MPV_common_end(s);
791 return -1;
792 }
793
794 /* init common structure for both encoder and decoder */
795 void MPV_common_end(MpegEncContext *s)
796 {
797 int i, j, k;
798
799 if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
800 for(i=0; i<s->avctx->thread_count; i++){
801 free_duplicate_context(s->thread_context[i]);
802 }
803 for(i=1; i<s->avctx->thread_count; i++){
804 av_freep(&s->thread_context[i]);
805 }
806 } else free_duplicate_context(s);
807
808 av_freep(&s->parse_context.buffer);
809 s->parse_context.buffer_size=0;
810
811 av_freep(&s->mb_type);
812 av_freep(&s->p_mv_table_base);
813 av_freep(&s->b_forw_mv_table_base);
814 av_freep(&s->b_back_mv_table_base);
815 av_freep(&s->b_bidir_forw_mv_table_base);
816 av_freep(&s->b_bidir_back_mv_table_base);
817 av_freep(&s->b_direct_mv_table_base);
818 s->p_mv_table= NULL;
819 s->b_forw_mv_table= NULL;
820 s->b_back_mv_table= NULL;
821 s->b_bidir_forw_mv_table= NULL;
822 s->b_bidir_back_mv_table= NULL;
823 s->b_direct_mv_table= NULL;
824 for(i=0; i<2; i++){
825 for(j=0; j<2; j++){
826 for(k=0; k<2; k++){
827 av_freep(&s->b_field_mv_table_base[i][j][k]);
828 s->b_field_mv_table[i][j][k]=NULL;
829 }
830 av_freep(&s->b_field_select_table[i][j]);
831 av_freep(&s->p_field_mv_table_base[i][j]);
832 s->p_field_mv_table[i][j]=NULL;
833 }
834 av_freep(&s->p_field_select_table[i]);
835 }
836
837 av_freep(&s->dc_val_base);
838 av_freep(&s->coded_block_base);
839 av_freep(&s->mbintra_table);
840 av_freep(&s->cbp_table);
841 av_freep(&s->pred_dir_table);
842
843 av_freep(&s->mbskip_table);
844 av_freep(&s->prev_pict_types);
845 av_freep(&s->bitstream_buffer);
846 s->allocated_bitstream_buffer_size=0;
847
848 av_freep(&s->avctx->stats_out);
849 av_freep(&s->ac_stats);
850 av_freep(&s->error_status_table);
851 av_freep(&s->mb_index2xy);
852 av_freep(&s->lambda_table);
853 av_freep(&s->q_intra_matrix);
854 av_freep(&s->q_inter_matrix);
855 av_freep(&s->q_intra_matrix16);
856 av_freep(&s->q_inter_matrix16);
857 av_freep(&s->input_picture);
858 av_freep(&s->reordered_input_picture);
859 av_freep(&s->dct_offset);
860
861 if(s->picture && !s->avctx->is_copy){
862 for(i=0; i<s->picture_count; i++){
863 free_picture(s, &s->picture[i]);
864 }
865 }
866 av_freep(&s->picture);
867 s->context_initialized = 0;
868 s->last_picture_ptr=
869 s->next_picture_ptr=
870 s->current_picture_ptr= NULL;
871 s->linesize= s->uvlinesize= 0;
872
873 for(i=0; i<3; i++)
874 av_freep(&s->visualization_buffer[i]);
875
876 if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
877 avcodec_default_free_buffers(s->avctx);
878 }
879
880 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
881 {
882 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
883 uint8_t index_run[MAX_RUN+1];
884 int last, run, level, start, end, i;
885
886 /* If table is static, we can quit if rl->max_level[0] is not NULL */
887 if(static_store && rl->max_level[0])
888 return;
889
890 /* compute max_level[], max_run[] and index_run[] */
891 for(last=0;last<2;last++) {
892 if (last == 0) {
893 start = 0;
894 end = rl->last;
895 } else {
896 start = rl->last;
897 end = rl->n;
898 }
899
900 memset(max_level, 0, MAX_RUN + 1);
901 memset(max_run, 0, MAX_LEVEL + 1);
902 memset(index_run, rl->n, MAX_RUN + 1);
903 for(i=start;i<end;i++) {
904 run = rl->table_run[i];
905 level = rl->table_level[i];
906 if (index_run[run] == rl->n)
907 index_run[run] = i;
908 if (level > max_level[run])
909 max_level[run] = level;
910 if (run > max_run[level])
911 max_run[level] = run;
912 }
913 if(static_store)
914 rl->max_level[last] = static_store[last];
915 else
916 rl->max_level[last] = av_malloc(MAX_RUN + 1);
917 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
918 if(static_store)
919 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
920 else
921 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
922 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
923 if(static_store)
924 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
925 else
926 rl->index_run[last] = av_malloc(MAX_RUN + 1);
927 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
928 }
929 }
930
931 void init_vlc_rl(RLTable *rl)
932 {
933 int i, q;
934
935 for(q=0; q<32; q++){
936 int qmul= q*2;
937 int qadd= (q-1)|1;
938
939 if(q==0){
940 qmul=1;
941 qadd=0;
942 }
943 for(i=0; i<rl->vlc.table_size; i++){
944 int code= rl->vlc.table[i][0];
945 int len = rl->vlc.table[i][1];
946 int level, run;
947
948 if(len==0){ // illegal code
949 run= 66;
950 level= MAX_LEVEL;
951 }else if(len<0){ //more bits needed
952 run= 0;
953 level= code;
954 }else{
955 if(code==rl->n){ //esc
956 run= 66;
957 level= 0;
958 }else{
959 run= rl->table_run [code] + 1;
960 level= rl->table_level[code] * qmul + qadd;
961 if(code >= rl->last) run+=192;
962 }
963 }
964 rl->rl_vlc[q][i].len= len;
965 rl->rl_vlc[q][i].level= level;
966 rl->rl_vlc[q][i].run= run;
967 }
968 }
969 }
970
971 void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
972 {
973 int i;
974
975 /* release non reference frames */
976 for(i=0; i<s->picture_count; i++){
977 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
978 && (!s->picture[i].owner2 || s->picture[i].owner2 == s)
979 && (remove_current || &s->picture[i] != s->current_picture_ptr)
980 /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
981 free_frame_buffer(s, &s->picture[i]);
982 }
983 }
984 }
985
986 int ff_find_unused_picture(MpegEncContext *s, int shared){
987 int i;
988
989 if(shared){
990 for(i=s->picture_range_start; i<s->picture_range_end; i++){
991 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
992 return i;
993 }
994 }else{
995 for(i=s->picture_range_start; i<s->picture_range_end; i++){
996 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
997 return i; //FIXME
998 }
999 for(i=s->picture_range_start; i<s->picture_range_end; i++){
1000 if (s->picture[i].f.data[0] == NULL)
1001 return i;
1002 }
1003 }
1004
1005 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
1006 /* We could return -1, but the codec would crash trying to draw into a
1007 * non-existing frame anyway. This is safer than waiting for a random crash.
1008 * Also the return of this is never useful, an encoder must only allocate
1009 * as much as allowed in the specification. This has no relationship to how
1010 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1011 * enough for such valid streams).
1012 * Plus, a decoder has to check stream validity and remove frames if too
1013 * many reference frames are around. Waiting for "OOM" is not correct at
1014 * all. Similarly, missing reference frames have to be replaced by
1015 * interpolated/MC frames, anything else is a bug in the codec ...
1016 */
1017 abort();
1018 return -1;
1019 }
1020
1021 static void update_noise_reduction(MpegEncContext *s){
1022 int intra, i;
1023
1024 for(intra=0; intra<2; intra++){
1025 if(s->dct_count[intra] > (1<<16)){
1026 for(i=0; i<64; i++){
1027 s->dct_error_sum[intra][i] >>=1;
1028 }
1029 s->dct_count[intra] >>= 1;
1030 }
1031
1032 for(i=0; i<64; i++){
1033 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1034 }
1035 }
1036 }
1037
1038 /**
1039 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1040 */
1041 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1042 {
1043 int i;
1044 Picture *pic;
1045 s->mb_skipped = 0;
1046
1047 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1048
1049 /* mark&release old frames */
1050 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->f.data[0]) {
1051 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1052 if (s->last_picture_ptr->owner2 == s)
1053 free_frame_buffer(s, s->last_picture_ptr);
1054
1055 /* release forgotten pictures */
1056 /* if(mpeg124/h263) */
1057 if(!s->encoding){
1058 for(i=0; i<s->picture_count; i++){
1059 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].f.reference) {
1060 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1061 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1062 free_frame_buffer(s, &s->picture[i]);
1063 }
1064 }
1065 }
1066 }
1067 }
1068
1069 if(!s->encoding){
1070 ff_release_unused_pictures(s, 1);
1071
1072 if (s->current_picture_ptr && s->current_picture_ptr->f.data[0] == NULL)
1073 pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1074 else{
1075 i= ff_find_unused_picture(s, 0);
1076 pic= &s->picture[i];
1077 }
1078
1079 pic->f.reference = 0;
1080 if (!s->dropable){
1081 if (s->codec_id == CODEC_ID_H264)
1082 pic->f.reference = s->picture_structure;
1083 else if (s->pict_type != AV_PICTURE_TYPE_B)
1084 pic->f.reference = 3;
1085 }
1086
1087 pic->f.coded_picture_number = s->coded_picture_number++;
1088
1089 if(ff_alloc_picture(s, pic, 0) < 0)
1090 return -1;
1091
1092 s->current_picture_ptr= pic;
1093 //FIXME use only the vars from current_pic
1094 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1095 if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1096 if(s->picture_structure != PICT_FRAME)
1097 s->current_picture_ptr->f.top_field_first = (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1098 }
1099 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame && !s->progressive_sequence;
1100 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1101 }
1102
1103 s->current_picture_ptr->f.pict_type = s->pict_type;
1104 // if(s->flags && CODEC_FLAG_QSCALE)
1105 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1106 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1107
1108 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1109
1110 if (s->pict_type != AV_PICTURE_TYPE_B) {
1111 s->last_picture_ptr= s->next_picture_ptr;
1112 if(!s->dropable)
1113 s->next_picture_ptr= s->current_picture_ptr;
1114 }
1115 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1116 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1117 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1118 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1119 s->pict_type, s->dropable);*/
1120
1121 if(s->codec_id != CODEC_ID_H264){
1122 if ((s->last_picture_ptr == NULL || s->last_picture_ptr->f.data[0] == NULL) &&
1123 (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1124 if (s->pict_type != AV_PICTURE_TYPE_I)
1125 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1126 else if (s->picture_structure != PICT_FRAME)
1127 av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1128
1129 /* Allocate a dummy frame */
1130 i= ff_find_unused_picture(s, 0);
1131 s->last_picture_ptr= &s->picture[i];
1132 if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1133 return -1;
1134 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1135 ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1136 }
1137 if ((s->next_picture_ptr == NULL || s->next_picture_ptr->f.data[0] == NULL) && s->pict_type == AV_PICTURE_TYPE_B) {
1138 /* Allocate a dummy frame */
1139 i= ff_find_unused_picture(s, 0);
1140 s->next_picture_ptr= &s->picture[i];
1141 if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1142 return -1;
1143 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1144 ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1145 }
1146 }
1147
1148 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1149 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1150
1151 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->f.data[0]));
1152
1153 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1154 int i;
1155 for(i=0; i<4; i++){
1156 if(s->picture_structure == PICT_BOTTOM_FIELD){
1157 s->current_picture.f.data[i] += s->current_picture.f.linesize[i];
1158 }
1159 s->current_picture.f.linesize[i] *= 2;
1160 s->last_picture.f.linesize[i] *= 2;
1161 s->next_picture.f.linesize[i] *= 2;
1162 }
1163 }
1164
1165 s->error_recognition= avctx->error_recognition;
1166
1167 /* set dequantizer, we can't do it during init as it might change for mpeg4
1168 and we can't do it in the header decode as init is not called for mpeg4 there yet */
1169 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1170 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1171 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1172 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1173 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1174 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1175 }else{
1176 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1177 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1178 }
1179
1180 if(s->dct_error_sum){
1181 assert(s->avctx->noise_reduction && s->encoding);
1182
1183 update_noise_reduction(s);
1184 }
1185
1186 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1187 return ff_xvmc_field_start(s, avctx);
1188
1189 return 0;
1190 }
1191
1192 /* generic function for encode/decode called after a frame has been coded/decoded */
1193 void MPV_frame_end(MpegEncContext *s)
1194 {
1195 int i;
1196 /* redraw edges for the frame if decoding didn't complete */
1197 //just to make sure that all data is rendered.
1198 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1199 ff_xvmc_field_end(s);
1200 }else if((s->error_count || s->encoding)
1201 && !s->avctx->hwaccel
1202 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1203 && s->unrestricted_mv
1204 && s->current_picture.f.reference
1205 && !s->intra_only
1206 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1207 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1208 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1209 s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1210 s->h_edge_pos , s->v_edge_pos,
1211 EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1212 s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1213 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1214 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1215 s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1216 s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1217 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1218 }
1219
1220 emms_c();
1221
1222 s->last_pict_type = s->pict_type;
1223 s->last_lambda_for[s->pict_type] = s->current_picture_ptr->f.quality;
1224 if(s->pict_type!=AV_PICTURE_TYPE_B){
1225 s->last_non_b_pict_type= s->pict_type;
1226 }
1227 #if 0
1228 /* copy back current_picture variables */
1229 for(i=0; i<MAX_PICTURE_COUNT; i++){
1230 if(s->picture[i].f.data[0] == s->current_picture.f.data[0]){
1231 s->picture[i]= s->current_picture;
1232 break;
1233 }
1234 }
1235 assert(i<MAX_PICTURE_COUNT);
1236 #endif
1237
1238 if(s->encoding){
1239 /* release non-reference frames */
1240 for(i=0; i<s->picture_count; i++){
1241 if (s->picture[i].f.data[0] && !s->picture[i].f.reference /*&& s->picture[i].type != FF_BUFFER_TYPE_SHARED*/) {
1242 free_frame_buffer(s, &s->picture[i]);
1243 }
1244 }
1245 }
1246 // clear copies, to avoid confusion
1247 #if 0
1248 memset(&s->last_picture, 0, sizeof(Picture));
1249 memset(&s->next_picture, 0, sizeof(Picture));
1250 memset(&s->current_picture, 0, sizeof(Picture));
1251 #endif
1252 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1253
1254 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1255 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1256 }
1257 }
1258
1259 /**
1260 * draws an line from (ex, ey) -> (sx, sy).
1261 * @param w width of the image
1262 * @param h height of the image
1263 * @param stride stride/linesize of the image
1264 * @param color color of the arrow
1265 */
1266 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1267 int x, y, fr, f;
1268
1269 sx= av_clip(sx, 0, w-1);
1270 sy= av_clip(sy, 0, h-1);
1271 ex= av_clip(ex, 0, w-1);
1272 ey= av_clip(ey, 0, h-1);
1273
1274 buf[sy*stride + sx]+= color;
1275
1276 if(FFABS(ex - sx) > FFABS(ey - sy)){
1277 if(sx > ex){
1278 FFSWAP(int, sx, ex);
1279 FFSWAP(int, sy, ey);
1280 }
1281 buf+= sx + sy*stride;
1282 ex-= sx;
1283 f= ((ey-sy)<<16)/ex;
1284 for(x= 0; x <= ex; x++){
1285 y = (x*f)>>16;
1286 fr= (x*f)&0xFFFF;
1287 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1288 buf[(y+1)*stride + x]+= (color* fr )>>16;
1289 }
1290 }else{
1291 if(sy > ey){
1292 FFSWAP(int, sx, ex);
1293 FFSWAP(int, sy, ey);
1294 }
1295 buf+= sx + sy*stride;
1296 ey-= sy;
1297 if(ey) f= ((ex-sx)<<16)/ey;
1298 else f= 0;
1299 for(y= 0; y <= ey; y++){
1300 x = (y*f)>>16;
1301 fr= (y*f)&0xFFFF;
1302 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1303 buf[y*stride + x+1]+= (color* fr )>>16;
1304 }
1305 }
1306 }
1307
1308 /**
1309 * draws an arrow from (ex, ey) -> (sx, sy).
1310 * @param w width of the image
1311 * @param h height of the image
1312 * @param stride stride/linesize of the image
1313 * @param color color of the arrow
1314 */
1315 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1316 int dx,dy;
1317
1318 sx= av_clip(sx, -100, w+100);
1319 sy= av_clip(sy, -100, h+100);
1320 ex= av_clip(ex, -100, w+100);
1321 ey= av_clip(ey, -100, h+100);
1322
1323 dx= ex - sx;
1324 dy= ey - sy;
1325
1326 if(dx*dx + dy*dy > 3*3){
1327 int rx= dx + dy;
1328 int ry= -dx + dy;
1329 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1330
1331 //FIXME subpixel accuracy
1332 rx= ROUNDED_DIV(rx*3<<4, length);
1333 ry= ROUNDED_DIV(ry*3<<4, length);
1334
1335 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1336 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1337 }
1338 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1339 }
1340
1341 /**
1342 * prints debuging info for the given picture.
1343 */
1344 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1345
1346 if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1347
1348 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1349 int x,y;
1350
1351 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1352 switch (pict->pict_type) {
1353 case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1354 case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1355 case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1356 case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1357 case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1358 case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1359 }
1360 for(y=0; y<s->mb_height; y++){
1361 for(x=0; x<s->mb_width; x++){
1362 if(s->avctx->debug&FF_DEBUG_SKIP){
1363 int count= s->mbskip_table[x + y*s->mb_stride];
1364 if(count>9) count=9;
1365 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1366 }
1367 if(s->avctx->debug&FF_DEBUG_QP){
1368 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1369 }
1370 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1371 int mb_type= pict->mb_type[x + y*s->mb_stride];
1372 //Type & MV direction
1373 if(IS_PCM(mb_type))
1374 av_log(s->avctx, AV_LOG_DEBUG, "P");
1375 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1376 av_log(s->avctx, AV_LOG_DEBUG, "A");
1377 else if(IS_INTRA4x4(mb_type))
1378 av_log(s->avctx, AV_LOG_DEBUG, "i");
1379 else if(IS_INTRA16x16(mb_type))
1380 av_log(s->avctx, AV_LOG_DEBUG, "I");
1381 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1382 av_log(s->avctx, AV_LOG_DEBUG, "d");
1383 else if(IS_DIRECT(mb_type))
1384 av_log(s->avctx, AV_LOG_DEBUG, "D");
1385 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1386 av_log(s->avctx, AV_LOG_DEBUG, "g");
1387 else if(IS_GMC(mb_type))
1388 av_log(s->avctx, AV_LOG_DEBUG, "G");
1389 else if(IS_SKIP(mb_type))
1390 av_log(s->avctx, AV_LOG_DEBUG, "S");
1391 else if(!USES_LIST(mb_type, 1))
1392 av_log(s->avctx, AV_LOG_DEBUG, ">");
1393 else if(!USES_LIST(mb_type, 0))
1394 av_log(s->avctx, AV_LOG_DEBUG, "<");
1395 else{
1396 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1397 av_log(s->avctx, AV_LOG_DEBUG, "X");
1398 }
1399
1400 //segmentation
1401 if(IS_8X8(mb_type))
1402 av_log(s->avctx, AV_LOG_DEBUG, "+");
1403 else if(IS_16X8(mb_type))
1404 av_log(s->avctx, AV_LOG_DEBUG, "-");
1405 else if(IS_8X16(mb_type))
1406 av_log(s->avctx, AV_LOG_DEBUG, "|");
1407 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1408 av_log(s->avctx, AV_LOG_DEBUG, " ");
1409 else
1410 av_log(s->avctx, AV_LOG_DEBUG, "?");
1411
1412
1413 if(IS_INTERLACED(mb_type))
1414 av_log(s->avctx, AV_LOG_DEBUG, "=");
1415 else
1416 av_log(s->avctx, AV_LOG_DEBUG, " ");
1417 }
1418 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1419 }
1420 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1421 }
1422 }
1423
1424 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1425 const int shift= 1 + s->quarter_sample;
1426 int mb_y;
1427 uint8_t *ptr;
1428 int i;
1429 int h_chroma_shift, v_chroma_shift, block_height;
1430 const int width = s->avctx->width;
1431 const int height= s->avctx->height;
1432 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1433 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1434 s->low_delay=0; //needed to see the vectors without trashing the buffers
1435
1436 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1437 for(i=0; i<3; i++){
1438 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1439 pict->data[i]= s->visualization_buffer[i];
1440 }
1441 pict->type= FF_BUFFER_TYPE_COPY;
1442 ptr= pict->data[0];
1443 block_height = 16>>v_chroma_shift;
1444
1445 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1446 int mb_x;
1447 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1448 const int mb_index= mb_x + mb_y*s->mb_stride;
1449 if((s->avctx->debug_mv) && pict->motion_val){
1450 int type;
1451 for(type=0; type<3; type++){
1452 int direction = 0;
1453 switch (type) {
1454 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1455 continue;
1456 direction = 0;
1457 break;
1458 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1459 continue;
1460 direction = 0;
1461 break;
1462 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1463 continue;
1464 direction = 1;
1465 break;
1466 }
1467 if(!USES_LIST(pict->mb_type[mb_index], direction))
1468 continue;
1469
1470 if(IS_8X8(pict->mb_type[mb_index])){
1471 int i;
1472 for(i=0; i<4; i++){
1473 int sx= mb_x*16 + 4 + 8*(i&1);
1474 int sy= mb_y*16 + 4 + 8*(i>>1);
1475 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1476 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1477 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1478 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1479 }
1480 }else if(IS_16X8(pict->mb_type[mb_index])){
1481 int i;
1482 for(i=0; i<2; i++){
1483 int sx=mb_x*16 + 8;
1484 int sy=mb_y*16 + 4 + 8*i;
1485 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1486 int mx=(pict->motion_val[direction][xy][0]>>shift);
1487 int my=(pict->motion_val[direction][xy][1]>>shift);
1488
1489 if(IS_INTERLACED(pict->mb_type[mb_index]))
1490 my*=2;
1491
1492 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1493 }
1494 }else if(IS_8X16(pict->mb_type[mb_index])){
1495 int i;
1496 for(i=0; i<2; i++){
1497 int sx=mb_x*16 + 4 + 8*i;
1498 int sy=mb_y*16 + 8;
1499 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1500 int mx=(pict->motion_val[direction][xy][0]>>shift);
1501 int my=(pict->motion_val[direction][xy][1]>>shift);
1502
1503 if(IS_INTERLACED(pict->mb_type[mb_index]))
1504 my*=2;
1505
1506 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1507 }
1508 }else{
1509 int sx= mb_x*16 + 8;
1510 int sy= mb_y*16 + 8;
1511 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1512 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1513 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1514 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1515 }
1516 }
1517 }
1518 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1519 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1520 int y;
1521 for(y=0; y<block_height; y++){
1522 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1523 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1524 }
1525 }
1526 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1527 int mb_type= pict->mb_type[mb_index];
1528 uint64_t u,v;
1529 int y;
1530 #define COLOR(theta, r)\
1531 u= (int)(128 + r*cos(theta*3.141592/180));\
1532 v= (int)(128 + r*sin(theta*3.141592/180));
1533
1534
1535 u=v=128;
1536 if(IS_PCM(mb_type)){
1537 COLOR(120,48)
1538 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1539 COLOR(30,48)
1540 }else if(IS_INTRA4x4(mb_type)){
1541 COLOR(90,48)
1542 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1543 // COLOR(120,48)
1544 }else if(IS_DIRECT(mb_type)){
1545 COLOR(150,48)
1546 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1547 COLOR(170,48)
1548 }else if(IS_GMC(mb_type)){
1549 COLOR(190,48)
1550 }else if(IS_SKIP(mb_type)){
1551 // COLOR(180,48)
1552 }else if(!USES_LIST(mb_type, 1)){
1553 COLOR(240,48)
1554 }else if(!USES_LIST(mb_type, 0)){
1555 COLOR(0,48)
1556 }else{
1557 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1558 COLOR(300,48)
1559 }
1560
1561 u*= 0x0101010101010101ULL;
1562 v*= 0x0101010101010101ULL;
1563 for(y=0; y<block_height; y++){
1564 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1565 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1566 }
1567
1568 //segmentation
1569 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1570 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1571 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1572 }
1573 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1574 for(y=0; y<16; y++)
1575 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1576 }
1577 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1578 int dm= 1 << (mv_sample_log2-2);
1579 for(i=0; i<4; i++){
1580 int sx= mb_x*16 + 8*(i&1);
1581 int sy= mb_y*16 + 8*(i>>1);
1582 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1583 //FIXME bidir
1584 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1585 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1586 for(y=0; y<8; y++)
1587 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1588 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1589 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1590 }
1591 }
1592
1593 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1594 // hmm
1595 }
1596 }
1597 s->mbskip_table[mb_index]=0;
1598 }
1599 }
1600 }
1601 }
1602
1603 static inline int hpel_motion_lowres(MpegEncContext *s,
1604 uint8_t *dest, uint8_t *src,
1605 int field_based, int field_select,
1606 int src_x, int src_y,
1607 int width, int height, int stride,
1608 int h_edge_pos, int v_edge_pos,
1609 int w, int h, h264_chroma_mc_func *pix_op,
1610 int motion_x, int motion_y)
1611 {
1612 const int lowres= s->avctx->lowres;
1613 const int op_index= FFMIN(lowres, 2);
1614 const int s_mask= (2<<lowres)-1;
1615 int emu=0;
1616 int sx, sy;
1617
1618 if(s->quarter_sample){
1619 motion_x/=2;
1620 motion_y/=2;
1621 }
1622
1623 sx= motion_x & s_mask;
1624 sy= motion_y & s_mask;
1625 src_x += motion_x >> (lowres+1);
1626 src_y += motion_y >> (lowres+1);
1627
1628 src += src_y * stride + src_x;
1629
1630 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1631 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1632 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1633 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1634 src= s->edge_emu_buffer;
1635 emu=1;
1636 }
1637
1638 sx= (sx << 2) >> lowres;
1639 sy= (sy << 2) >> lowres;
1640 if(field_select)
1641 src += s->linesize;
1642 pix_op[op_index](dest, src, stride, h, sx, sy);
1643 return emu;
1644 }
1645
1646 /* apply one mpeg motion vector to the three components */
1647 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1648 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1649 int field_based, int bottom_field, int field_select,
1650 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1651 int motion_x, int motion_y, int h, int mb_y)
1652 {
1653 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1654 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1655 const int lowres= s->avctx->lowres;
1656 const int op_index= FFMIN(lowres, 2);
1657 const int block_s= 8>>lowres;
1658 const int s_mask= (2<<lowres)-1;
1659 const int h_edge_pos = s->h_edge_pos >> lowres;
1660 const int v_edge_pos = s->v_edge_pos >> lowres;
1661 linesize = s->current_picture.f.linesize[0] << field_based;
1662 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1663
1664 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1665 motion_x/=2;
1666 motion_y/=2;
1667 }
1668
1669 if(field_based){
1670 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1671 }
1672
1673 sx= motion_x & s_mask;
1674 sy= motion_y & s_mask;
1675 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1676 src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1677
1678 if (s->out_format == FMT_H263) {
1679 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1680 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1681 uvsrc_x = src_x>>1;
1682 uvsrc_y = src_y>>1;
1683 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1684 mx = motion_x / 4;
1685 my = motion_y / 4;
1686 uvsx = (2*mx) & s_mask;
1687 uvsy = (2*my) & s_mask;
1688 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1689 uvsrc_y = mb_y*block_s + (my >> lowres);
1690 } else {
1691 mx = motion_x / 2;
1692 my = motion_y / 2;
1693 uvsx = mx & s_mask;
1694 uvsy = my & s_mask;
1695 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1696 uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1697 }
1698
1699 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1700 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1701 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1702
1703 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1704 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1705 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1706 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1707 ptr_y = s->edge_emu_buffer;
1708 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1709 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1710 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1711 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1712 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1713 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1714 ptr_cb= uvbuf;
1715 ptr_cr= uvbuf+16;
1716 }
1717 }
1718
1719 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1720 dest_y += s->linesize;
1721 dest_cb+= s->uvlinesize;
1722 dest_cr+= s->uvlinesize;
1723 }
1724
1725 if(field_select){
1726 ptr_y += s->linesize;
1727 ptr_cb+= s->uvlinesize;
1728 ptr_cr+= s->uvlinesize;
1729 }
1730
1731 sx= (sx << 2) >> lowres;
1732 sy= (sy << 2) >> lowres;
1733 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1734
1735 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1736 uvsx= (uvsx << 2) >> lowres;
1737 uvsy= (uvsy << 2) >> lowres;
1738 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1739 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1740 }
1741 //FIXME h261 lowres loop filter
1742 }
1743
1744 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1745 uint8_t *dest_cb, uint8_t *dest_cr,
1746 uint8_t **ref_picture,
1747 h264_chroma_mc_func *pix_op,
1748 int mx, int my){
1749 const int lowres= s->avctx->lowres;
1750 const int op_index= FFMIN(lowres, 2);
1751 const int block_s= 8>>lowres;
1752 const int s_mask= (2<<lowres)-1;
1753 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1754 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1755 int emu=0, src_x, src_y, offset, sx, sy;
1756 uint8_t *ptr;
1757
1758 if(s->quarter_sample){
1759 mx/=2;
1760 my/=2;
1761 }
1762
1763 /* In case of 8X8, we construct a single chroma motion vector
1764 with a special rounding */
1765 mx= ff_h263_round_chroma(mx);
1766 my= ff_h263_round_chroma(my);
1767
1768 sx= mx & s_mask;
1769 sy= my & s_mask;
1770 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1771 src_y = s->mb_y*block_s + (my >> (lowres+1));
1772
1773 offset = src_y * s->uvlinesize + src_x;
1774 ptr = ref_picture[1] + offset;
1775 if(s->flags&CODEC_FLAG_EMU_EDGE){
1776 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1777 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1778 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1779 ptr= s->edge_emu_buffer;
1780 emu=1;
1781 }
1782 }
1783 sx= (sx << 2) >> lowres;
1784 sy= (sy << 2) >> lowres;
1785 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1786
1787 ptr = ref_picture[2] + offset;
1788 if(emu){
1789 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1790 ptr= s->edge_emu_buffer;
1791 }
1792 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1793 }
1794
1795 /**
1796 * motion compensation of a single macroblock
1797 * @param s context
1798 * @param dest_y luma destination pointer
1799 * @param dest_cb chroma cb/u destination pointer
1800 * @param dest_cr chroma cr/v destination pointer
1801 * @param dir direction (0->forward, 1->backward)
1802 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1803 * @param pix_op halfpel motion compensation function (average or put normally)
1804 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1805 */
1806 static inline void MPV_motion_lowres(MpegEncContext *s,
1807 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1808 int dir, uint8_t **ref_picture,
1809 h264_chroma_mc_func *pix_op)
1810 {
1811 int mx, my;
1812 int mb_x, mb_y, i;
1813 const int lowres= s->avctx->lowres;
1814 const int block_s= 8>>lowres;
1815
1816 mb_x = s->mb_x;
1817 mb_y = s->mb_y;
1818
1819 switch(s->mv_type) {
1820 case MV_TYPE_16X16:
1821 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1822 0, 0, 0,
1823 ref_picture, pix_op,
1824 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1825 break;
1826 case MV_TYPE_8X8:
1827 mx = 0;
1828 my = 0;
1829 for(i=0;i<4;i++) {
1830 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1831 ref_picture[0], 0, 0,
1832 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1833 s->width, s->height, s->linesize,
1834 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1835 block_s, block_s, pix_op,
1836 s->mv[dir][i][0], s->mv[dir][i][1]);
1837
1838 mx += s->mv[dir][i][0];
1839 my += s->mv[dir][i][1];
1840 }
1841
1842 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1843 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1844 break;
1845 case MV_TYPE_FIELD:
1846 if (s->picture_structure == PICT_FRAME) {
1847 /* top field */
1848 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1849 1, 0, s->field_select[dir][0],
1850 ref_picture, pix_op,
1851 s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1852 /* bottom field */
1853 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1854 1, 1, s->field_select[dir][1],
1855 ref_picture, pix_op,
1856 s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1857 } else {
1858 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1859 ref_picture = s->current_picture_ptr->f.data;
1860 }
1861
1862 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1863 0, 0, s->field_select[dir][0],
1864 ref_picture, pix_op,
1865 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1866 }
1867 break;
1868 case MV_TYPE_16X8:
1869 for(i=0; i<2; i++){
1870 uint8_t ** ref2picture;
1871
1872 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1873 ref2picture= ref_picture;
1874 }else{
1875 ref2picture = s->current_picture_ptr->f.data;
1876 }
1877
1878 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1879 0, 0, s->field_select[dir][i],
1880 ref2picture, pix_op,
1881 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1882
1883 dest_y += 2*block_s*s->linesize;
1884 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1885 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1886 }
1887 break;
1888 case MV_TYPE_DMV:
1889 if(s->picture_structure == PICT_FRAME){
1890 for(i=0; i<2; i++){
1891 int j;
1892 for(j=0; j<2; j++){
1893 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1894 1, j, j^i,
1895 ref_picture, pix_op,
1896 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1897 }
1898 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1899 }
1900 }else{
1901 for(i=0; i<2; i++){
1902 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1903 0, 0, s->picture_structure != i+1,
1904 ref_picture, pix_op,
1905 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1906
1907 // after put we make avg of the same block
1908 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1909
1910 //opposite parity is always in the same frame if this is second field
1911 if(!s->first_field){
1912 ref_picture = s->current_picture_ptr->f.data;
1913 }
1914 }
1915 }
1916 break;
1917 default: assert(0);
1918 }
1919 }
1920
1921 /**
1922 * find the lowest MB row referenced in the MVs
1923 */
1924 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1925 {
1926 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1927 int my, off, i, mvs;
1928
1929 if (s->picture_structure != PICT_FRAME) goto unhandled;
1930
1931 switch (s->mv_type) {
1932 case MV_TYPE_16X16:
1933 mvs = 1;
1934 break;
1935 case MV_TYPE_16X8:
1936 mvs = 2;
1937 break;
1938 case MV_TYPE_8X8:
1939 mvs = 4;
1940 break;
1941 default:
1942 goto unhandled;
1943 }
1944
1945 for (i = 0; i < mvs; i++) {
1946 my = s->mv[dir][i][1]<<qpel_shift;
1947 my_max = FFMAX(my_max, my);
1948 my_min = FFMIN(my_min, my);
1949 }
1950
1951 off = (FFMAX(-my_min, my_max) + 63) >> 6;
1952
1953 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1954 unhandled:
1955 return s->mb_height-1;
1956 }
1957
1958 /* put block[] to dest[] */
1959 static inline void put_dct(MpegEncContext *s,
1960 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1961 {
1962 s->dct_unquantize_intra(s, block, i, qscale);
1963 s->dsp.idct_put (dest, line_size, block);
1964 }
1965
1966 /* add block[] to dest[] */
1967 static inline void add_dct(MpegEncContext *s,
1968 DCTELEM *block, int i, uint8_t *dest, int line_size)
1969 {
1970 if (s->block_last_index[i] >= 0) {
1971 s->dsp.idct_add (dest, line_size, block);
1972 }
1973 }
1974
1975 static inline void add_dequant_dct(MpegEncContext *s,
1976 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1977 {
1978 if (s->block_last_index[i] >= 0) {
1979 s->dct_unquantize_inter(s, block, i, qscale);
1980
1981 s->dsp.idct_add (dest, line_size, block);
1982 }
1983 }
1984
1985 /**
1986 * cleans dc, ac, coded_block for the current non intra MB
1987 */
1988 void ff_clean_intra_table_entries(MpegEncContext *s)
1989 {
1990 int wrap = s->b8_stride;
1991 int xy = s->block_index[0];
1992
1993 s->dc_val[0][xy ] =
1994 s->dc_val[0][xy + 1 ] =
1995 s->dc_val[0][xy + wrap] =
1996 s->dc_val[0][xy + 1 + wrap] = 1024;
1997 /* ac pred */
1998 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1999 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2000 if (s->msmpeg4_version>=3) {
2001 s->coded_block[xy ] =
2002 s->coded_block[xy + 1 ] =
2003 s->coded_block[xy + wrap] =
2004 s->coded_block[xy + 1 + wrap] = 0;
2005 }
2006 /* chroma */
2007 wrap = s->mb_stride;
2008 xy = s->mb_x + s->mb_y * wrap;
2009 s->dc_val[1][xy] =
2010 s->dc_val[2][xy] = 1024;
2011 /* ac pred */
2012 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2013 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2014
2015 s->mbintra_table[xy]= 0;
2016 }
2017
2018 /* generic function called after a macroblock has been parsed by the
2019 decoder or after it has been encoded by the encoder.
2020
2021 Important variables used:
2022 s->mb_intra : true if intra macroblock
2023 s->mv_dir : motion vector direction
2024 s->mv_type : motion vector type
2025 s->mv : motion vector
2026 s->interlaced_dct : true if interlaced dct used (mpeg2)
2027 */
2028 static av_always_inline
2029 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2030 int lowres_flag, int is_mpeg12)
2031 {
2032 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2033 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2034 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2035 return;
2036 }
2037
2038 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2039 /* save DCT coefficients */
2040 int i,j;
2041 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2042 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2043 for(i=0; i<6; i++){
2044 for(j=0; j<64; j++){
2045 *dct++ = block[i][s->dsp.idct_permutation[j]];
2046 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2047 }
2048 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2049 }
2050 }
2051
2052 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2053
2054 /* update DC predictors for P macroblocks */
2055 if (!s->mb_intra) {
2056 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2057 if(s->mbintra_table[mb_xy])
2058 ff_clean_intra_table_entries(s);
2059 } else {
2060 s->last_dc[0] =
2061 s->last_dc[1] =
2062 s->last_dc[2] = 128 << s->intra_dc_precision;
2063 }
2064 }
2065 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2066 s->mbintra_table[mb_xy]=1;
2067
2068 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2069 uint8_t *dest_y, *dest_cb, *dest_cr;
2070 int dct_linesize, dct_offset;
2071 op_pixels_func (*op_pix)[4];
2072 qpel_mc_func (*op_qpix)[16];
2073 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2074 const int uvlinesize = s->current_picture.f.linesize[1];
2075 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2076 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2077
2078 /* avoid copy if macroblock skipped in last frame too */
2079 /* skip only during decoding as we might trash the buffers during encoding a bit */
2080 if(!s->encoding){
2081 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2082 const int age = s->current_picture.f.age;
2083
2084 assert(age);
2085
2086 if (s->mb_skipped) {
2087 s->mb_skipped= 0;
2088 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2089
2090 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2091 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2092
2093 /* if previous was skipped too, then nothing to do ! */
2094 if (*mbskip_ptr >= age && s->current_picture.f.reference){
2095 return;
2096 }
2097 } else if(!s->current_picture.f.reference) {
2098 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2099 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2100 } else{
2101 *mbskip_ptr = 0; /* not skipped */
2102 }
2103 }
2104
2105 dct_linesize = linesize << s->interlaced_dct;
2106 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2107
2108 if(readable){
2109 dest_y= s->dest[0];
2110 dest_cb= s->dest[1];
2111 dest_cr= s->dest[2];
2112 }else{
2113 dest_y = s->b_scratchpad;
2114 dest_cb= s->b_scratchpad+16*linesize;
2115 dest_cr= s->b_scratchpad+32*linesize;
2116 }
2117
2118 if (!s->mb_intra) {
2119 /* motion handling */
2120 /* decoding or more than one mb_type (MC was already done otherwise) */
2121 if(!s->encoding){
2122
2123 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2124 if (s->mv_dir & MV_DIR_FORWARD) {
2125 ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2126 }
2127 if (s->mv_dir & MV_DIR_BACKWARD) {
2128 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2129 }
2130 }
2131
2132 if(lowres_flag){
2133 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2134
2135 if (s->mv_dir & MV_DIR_FORWARD) {
2136 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2137 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2138 }
2139 if (s->mv_dir & MV_DIR_BACKWARD) {
2140 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2141 }
2142 }else{
2143 op_qpix= s->me.qpel_put;
2144 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2145 op_pix = s->dsp.put_pixels_tab;
2146 }else{
2147 op_pix = s->dsp.put_no_rnd_pixels_tab;
2148 }
2149 if (s->mv_dir & MV_DIR_FORWARD) {
2150 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2151 op_pix = s->dsp.avg_pixels_tab;
2152 op_qpix= s->me.qpel_avg;
2153 }
2154 if (s->mv_dir & MV_DIR_BACKWARD) {
2155 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2156 }
2157 }
2158 }
2159
2160 /* skip dequant / idct if we are really late ;) */
2161 if(s->avctx->skip_idct){
2162 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2163 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2164 || s->avctx->skip_idct >= AVDISCARD_ALL)
2165 goto skip_idct;
2166 }
2167
2168 /* add dct residue */
2169 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2170 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2171 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2172 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2173 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2174 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2175
2176 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2177 if (s->chroma_y_shift){
2178 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2179 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2180 }else{
2181 dct_linesize >>= 1;
2182 dct_offset >>=1;
2183 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2184 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2185 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2186 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2187 }
2188 }
2189 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2190 add_dct(s, block[0], 0, dest_y , dct_linesize);
2191 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2192 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2193 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2194
2195 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2196 if(s->chroma_y_shift){//Chroma420
2197 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2198 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2199 }else{
2200 //chroma422
2201 dct_linesize = uvlinesize << s->interlaced_dct;
2202 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2203
2204 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2205 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2206 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2207 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2208 if(!s->chroma_x_shift){//Chroma444
2209 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2210 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2211 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2212 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2213 }
2214 }
2215 }//fi gray
2216 }
2217 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2218 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2219 }
2220 } else {
2221 /* dct only in intra block */
2222 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2223 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2224 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2225 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2226 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2227
2228 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2229 if(s->chroma_y_shift){
2230 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2231 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2232 }else{
2233 dct_offset >>=1;
2234 dct_linesize >>=1;
2235 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2236 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2237 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2238 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2239 }
2240 }
2241 }else{
2242 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2243 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2244 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2245 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2246
2247 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2248 if(s->chroma_y_shift){
2249 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2250 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2251 }else{
2252
2253 dct_linesize = uvlinesize << s->interlaced_dct;
2254 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2255
2256 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2257 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2258 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2259 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2260 if(!s->chroma_x_shift){//Chroma444
2261 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2262 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2263 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2264 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2265 }
2266 }
2267 }//gray
2268 }
2269 }
2270 skip_idct:
2271 if(!readable){
2272 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2273 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2274 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2275 }
2276 }
2277 }
2278
2279 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2280 #if !CONFIG_SMALL
2281 if(s->out_format == FMT_MPEG1) {
2282 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2283 else MPV_decode_mb_internal(s, block, 0, 1);
2284 } else
2285 #endif
2286 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2287 else MPV_decode_mb_internal(s, block, 0, 0);
2288 }
2289
2290 /**
2291 *
2292 * @param h is the normal height, this will be reduced automatically if needed for the last row
2293 */
2294 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2295 const int field_pic= s->picture_structure != PICT_FRAME;
2296 if(field_pic){
2297 h <<= 1;
2298 y <<= 1;
2299 }
2300
2301 if (!s->avctx->hwaccel
2302 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2303 && s->unrestricted_mv
2304 && s->current_picture.f.reference
2305 && !s->intra_only
2306 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2307 int sides = 0, edge_h;
2308 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2309 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2310 if (y==0) sides |= EDGE_TOP;
2311 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2312
2313 edge_h= FFMIN(h, s->v_edge_pos - y);
2314
2315 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2316 s->linesize, s->h_edge_pos, edge_h,
2317 EDGE_WIDTH, EDGE_WIDTH, sides);
2318 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2319 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2320 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2321 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2322 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2323 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2324 }
2325
2326 h= FFMIN(h, s->avctx->height - y);
2327
2328 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2329
2330 if (s->avctx->draw_horiz_band) {
2331 AVFrame *src;
2332 int offset[4];
2333
2334 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2335 src= (AVFrame*)s->current_picture_ptr;
2336 else if(s->last_picture_ptr)
2337 src= (AVFrame*)s->last_picture_ptr;
2338 else
2339 return;
2340
2341 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2342 offset[0]=
2343 offset[1]=
2344 offset[2]=
2345 offset[3]= 0;
2346 }else{
2347 offset[0]= y * s->linesize;
2348 offset[1]=
2349 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2350 offset[3]= 0;
2351 }
2352
2353 emms_c();
2354
2355 s->avctx->draw_horiz_band(s->avctx, src, offset,
2356 y, s->picture_structure, h);
2357 }
2358 }
2359
2360 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2361 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2362 const int uvlinesize = s->current_picture.f.linesize[1];
2363 const int mb_size= 4 - s->avctx->lowres;
2364
2365 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2366 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2367 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2368 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2369 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2370 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2371 //block_index is not used by mpeg2, so it is not affected by chroma_format
2372
2373 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2374 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2375 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2376
2377 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2378 {
2379 if(s->picture_structure==PICT_FRAME){
2380 s->dest[0] += s->mb_y * linesize << mb_size;
2381 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2382 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2383 }else{
2384 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2385 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2386 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2387 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2388 }
2389 }
2390 }
2391
2392 void ff_mpeg_flush(AVCodecContext *avctx){
2393 int i;
2394 MpegEncContext *s = avctx->priv_data;
2395
2396 if(s==NULL || s->picture==NULL)
2397 return;
2398
2399 for(i=0; i<s->picture_count; i++){
2400 if (s->picture[i].f.data[0] &&
2401 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2402 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2403 free_frame_buffer(s, &s->picture[i]);
2404 }
2405 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2406
2407 s->mb_x= s->mb_y= 0;
2408
2409 s->parse_context.state= -1;
2410 s->parse_context.frame_start_found= 0;
2411 s->parse_context.overread= 0;
2412 s->parse_context.overread_index= 0;
2413 s->parse_context.index= 0;
2414 s->parse_context.last_index= 0;
2415 s->bitstream_buffer_size=0;
2416 s->pp_time=0;
2417 }
2418
2419 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2420 DCTELEM *block, int n, int qscale)
2421 {
2422 int i, level, nCoeffs;
2423 const uint16_t *quant_matrix;
2424
2425 nCoeffs= s->block_last_index[n];
2426
2427 if (n < 4)
2428 block[0] = block[0] * s->y_dc_scale;
2429 else
2430 block[0] = block[0] * s->c_dc_scale;
2431 /* XXX: only mpeg1 */
2432 quant_matrix = s->intra_matrix;
2433 for(i=1;i<=nCoeffs;i++) {
2434 int j= s->intra_scantable.permutated[i];
2435 level = block[j];
2436 if (level) {
2437 if (level < 0) {
2438 level = -level;
2439 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2440 level = (level - 1) | 1;
2441 level = -level;
2442 } else {
2443 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2444 level = (level - 1) | 1;
2445 }
2446 block[j] = level;
2447 }
2448 }
2449 }
2450
2451 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2452 DCTELEM *block, int n, int qscale)
2453 {
2454 int i, level, nCoeffs;
2455 const uint16_t *quant_matrix;
2456
2457 nCoeffs= s->block_last_index[n];
2458
2459 quant_matrix = s->inter_matrix;
2460 for(i=0; i<=nCoeffs; i++) {
2461 int j= s->intra_scantable.permutated[i];
2462 level = block[j];
2463 if (level) {
2464 if (level < 0) {
2465 level = -level;
2466 level = (((level << 1) + 1) * qscale *
2467 ((int) (quant_matrix[j]))) >> 4;
2468 level = (level - 1) | 1;
2469 level = -level;
2470 } else {
2471 level = (((level << 1) + 1) * qscale *
2472 ((int) (quant_matrix[j]))) >> 4;
2473 level = (level - 1) | 1;
2474 }
2475 block[j] = level;
2476 }
2477 }
2478 }
2479
2480 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2481 DCTELEM *block, int n, int qscale)
2482 {
2483 int i, level, nCoeffs;
2484 const uint16_t *quant_matrix;
2485
2486 if(s->alternate_scan) nCoeffs= 63;
2487 else nCoeffs= s->block_last_index[n];
2488
2489 if (n < 4)
2490 block[0] = block[0] * s->y_dc_scale;
2491 else
2492 block[0] = block[0] * s->c_dc_scale;
2493 quant_matrix = s->intra_matrix;
2494 for(i=1;i<=nCoeffs;i++) {
2495 int j= s->intra_scantable.permutated[i];
2496 level = block[j];
2497 if (level) {
2498 if (level < 0) {
2499 level = -level;
2500 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2501 level = -level;
2502 } else {
2503 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2504 }
2505 block[j] = level;
2506 }
2507 }
2508 }
2509
2510 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2511 DCTELEM *block, int n, int qscale)
2512 {
2513 int i, level, nCoeffs;
2514 const uint16_t *quant_matrix;
2515 int sum=-1;
2516
2517 if(s->alternate_scan) nCoeffs= 63;
2518 else nCoeffs= s->block_last_index[n];
2519
2520 if (n < 4)
2521 block[0] = block[0] * s->y_dc_scale;
2522 else
2523 block[0] = block[0] * s->c_dc_scale;
2524 quant_matrix = s->intra_matrix;
2525 for(i=1;i<=nCoeffs;i++) {
2526 int j= s->intra_scantable.permutated[i];
2527 level = block[j];
2528 if (level) {
2529 if (level < 0) {
2530 level = -level;
2531 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2532 level = -level;
2533 } else {
2534 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2535 }
2536 block[j] = level;
2537 sum+=level;
2538 }
2539 }
2540 block[63]^=sum&1;
2541 }
2542
2543 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2544 DCTELEM *block, int n, int qscale)
2545 {
2546 int i, level, nCoeffs;
2547 const uint16_t *quant_matrix;
2548 int sum=-1;
2549
2550 if(s->alternate_scan) nCoeffs= 63;
2551 else nCoeffs= s->block_last_index[n];
2552
2553 quant_matrix = s->inter_matrix;
2554 for(i=0; i<=nCoeffs; i++) {
2555 int j= s->intra_scantable.permutated[i];
2556 level = block[j];
2557 if (level) {
2558 if (level < 0) {
2559 level = -level;
2560 level = (((level << 1) + 1) * qscale *
2561 ((int) (quant_matrix[j]))) >> 4;
2562 level = -level;
2563 } else {
2564 level = (((level << 1) + 1) * qscale *
2565 ((int) (quant_matrix[j]))) >> 4;
2566 }
2567 block[j] = level;
2568 sum+=level;
2569 }
2570 }
2571 block[63]^=sum&1;
2572 }
2573
2574 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2575 DCTELEM *block, int n, int qscale)
2576 {
2577 int i, level, qmul, qadd;
2578 int nCoeffs;
2579
2580 assert(s->block_last_index[n]>=0);
2581
2582 qmul = qscale << 1;
2583
2584 if (!s->h263_aic) {
2585 if (n < 4)
2586 block[0] = block[0] * s->y_dc_scale;
2587 else
2588 block[0] = block[0] * s->c_dc_scale;
2589 qadd = (qscale - 1) | 1;
2590 }else{
2591 qadd = 0;
2592 }
2593 if(s->ac_pred)
2594 nCoeffs=63;
2595 else
2596 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2597
2598 for(i=1; i<=nCoeffs; i++) {
2599 level = block[i];
2600 if (level) {
2601 if (level < 0) {
2602 level = level * qmul - qadd;
2603 } else {
2604 level = level * qmul + qadd;
2605 }
2606 block[i] = level;
2607 }
2608 }
2609 }
2610
2611 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2612 DCTELEM *block, int n, int qscale)
2613 {
2614 int i, level, qmul, qadd;
2615 int nCoeffs;
2616
2617 assert(s->block_last_index[n]>=0);
2618
2619 qadd = (qscale - 1) | 1;
2620 qmul = qscale << 1;
2621
2622 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2623
2624 for(i=0; i<=nCoeffs; i++) {
2625 level = block[i];
2626 if (level) {
2627 if (level < 0) {
2628 level = level * qmul - qadd;
2629 } else {
2630 level = level * qmul + qadd;
2631 }
2632 block[i] = level;
2633 }
2634 }
2635 }
2636
2637 /**
2638 * set qscale and update qscale dependent variables.
2639 */
2640 void ff_set_qscale(MpegEncContext * s, int qscale)
2641 {
2642 if (qscale < 1)
2643 qscale = 1;
2644 else if (qscale > 31)
2645 qscale = 31;
2646
2647 s->qscale = qscale;
2648 s->chroma_qscale= s->chroma_qscale_table[qscale];
2649
2650 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2651 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2652 }
2653
2654 void MPV_report_decode_progress(MpegEncContext *s)
2655 {
2656 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2657 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2658 }