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 FFmpeg.
9 *
10 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/motion_vector.h"
35 #include "libavutil/timer.h"
36 #include "avcodec.h"
37 #include "blockdsp.h"
38 #include "h264chroma.h"
39 #include "idctdsp.h"
40 #include "internal.h"
41 #include "mathops.h"
42 #include "mpegutils.h"
43 #include "mpegvideo.h"
44 #include "mjpegenc.h"
45 #include "msmpeg4.h"
46 #include "qpeldsp.h"
47 #include "thread.h"
48 #include <limits.h>
49
50 static const uint8_t ff_default_chroma_qscale_table[32] = {
51 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
52 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
53 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
54 };
55
56 const uint8_t ff_mpeg1_dc_scale_table[128] = {
57 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
58 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
59 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
60 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
61 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
62 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
63 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
64 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
65 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
66 };
67
68 static const uint8_t mpeg2_dc_scale_table1[128] = {
69 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
70 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
71 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
72 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
73 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
74 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
75 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
78 };
79
80 static const uint8_t mpeg2_dc_scale_table2[128] = {
81 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
82 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
90 };
91
92 static const uint8_t mpeg2_dc_scale_table3[128] = {
93 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
94 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
95 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
97 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
98 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
99 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
100 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,
102 };
103
104 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
105 ff_mpeg1_dc_scale_table,
106 mpeg2_dc_scale_table1,
107 mpeg2_dc_scale_table2,
108 mpeg2_dc_scale_table3,
109 };
110
111 const uint8_t ff_alternate_horizontal_scan[64] = {
112 0, 1, 2, 3, 8, 9, 16, 17,
113 10, 11, 4, 5, 6, 7, 15, 14,
114 13, 12, 19, 18, 24, 25, 32, 33,
115 26, 27, 20, 21, 22, 23, 28, 29,
116 30, 31, 34, 35, 40, 41, 48, 49,
117 42, 43, 36, 37, 38, 39, 44, 45,
118 46, 47, 50, 51, 56, 57, 58, 59,
119 52, 53, 54, 55, 60, 61, 62, 63,
120 };
121
122 const uint8_t ff_alternate_vertical_scan[64] = {
123 0, 8, 16, 24, 1, 9, 2, 10,
124 17, 25, 32, 40, 48, 56, 57, 49,
125 41, 33, 26, 18, 3, 11, 4, 12,
126 19, 27, 34, 42, 50, 58, 35, 43,
127 51, 59, 20, 28, 5, 13, 6, 14,
128 21, 29, 36, 44, 52, 60, 37, 45,
129 53, 61, 22, 30, 7, 15, 23, 31,
130 38, 46, 54, 62, 39, 47, 55, 63,
131 };
132
dct_unquantize_mpeg1_intra_c(MpegEncContext * s,int16_t * block,int n,int qscale)133 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
134 int16_t *block, int n, int qscale)
135 {
136 int i, level, nCoeffs;
137 const uint16_t *quant_matrix;
138
139 nCoeffs= s->block_last_index[n];
140
141 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
142 /* XXX: only mpeg1 */
143 quant_matrix = s->intra_matrix;
144 for(i=1;i<=nCoeffs;i++) {
145 int j= s->intra_scantable.permutated[i];
146 level = block[j];
147 if (level) {
148 if (level < 0) {
149 level = -level;
150 level = (int)(level * qscale * quant_matrix[j]) >> 3;
151 level = (level - 1) | 1;
152 level = -level;
153 } else {
154 level = (int)(level * qscale * quant_matrix[j]) >> 3;
155 level = (level - 1) | 1;
156 }
157 block[j] = level;
158 }
159 }
160 }
161
dct_unquantize_mpeg1_inter_c(MpegEncContext * s,int16_t * block,int n,int qscale)162 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
163 int16_t *block, int n, int qscale)
164 {
165 int i, level, nCoeffs;
166 const uint16_t *quant_matrix;
167
168 nCoeffs= s->block_last_index[n];
169
170 quant_matrix = s->inter_matrix;
171 for(i=0; i<=nCoeffs; i++) {
172 int j= s->intra_scantable.permutated[i];
173 level = block[j];
174 if (level) {
175 if (level < 0) {
176 level = -level;
177 level = (((level << 1) + 1) * qscale *
178 ((int) (quant_matrix[j]))) >> 4;
179 level = (level - 1) | 1;
180 level = -level;
181 } else {
182 level = (((level << 1) + 1) * qscale *
183 ((int) (quant_matrix[j]))) >> 4;
184 level = (level - 1) | 1;
185 }
186 block[j] = level;
187 }
188 }
189 }
190
dct_unquantize_mpeg2_intra_c(MpegEncContext * s,int16_t * block,int n,int qscale)191 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
192 int16_t *block, int n, int qscale)
193 {
194 int i, level, nCoeffs;
195 const uint16_t *quant_matrix;
196
197 if(s->alternate_scan) nCoeffs= 63;
198 else nCoeffs= s->block_last_index[n];
199
200 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
201 quant_matrix = s->intra_matrix;
202 for(i=1;i<=nCoeffs;i++) {
203 int j= s->intra_scantable.permutated[i];
204 level = block[j];
205 if (level) {
206 if (level < 0) {
207 level = -level;
208 level = (int)(level * qscale * quant_matrix[j]) >> 3;
209 level = -level;
210 } else {
211 level = (int)(level * qscale * quant_matrix[j]) >> 3;
212 }
213 block[j] = level;
214 }
215 }
216 }
217
dct_unquantize_mpeg2_intra_bitexact(MpegEncContext * s,int16_t * block,int n,int qscale)218 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
219 int16_t *block, int n, int qscale)
220 {
221 int i, level, nCoeffs;
222 const uint16_t *quant_matrix;
223 int sum=-1;
224
225 if(s->alternate_scan) nCoeffs= 63;
226 else nCoeffs= s->block_last_index[n];
227
228 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
229 sum += block[0];
230 quant_matrix = s->intra_matrix;
231 for(i=1;i<=nCoeffs;i++) {
232 int j= s->intra_scantable.permutated[i];
233 level = block[j];
234 if (level) {
235 if (level < 0) {
236 level = -level;
237 level = (int)(level * qscale * quant_matrix[j]) >> 3;
238 level = -level;
239 } else {
240 level = (int)(level * qscale * quant_matrix[j]) >> 3;
241 }
242 block[j] = level;
243 sum+=level;
244 }
245 }
246 block[63]^=sum&1;
247 }
248
dct_unquantize_mpeg2_inter_c(MpegEncContext * s,int16_t * block,int n,int qscale)249 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
250 int16_t *block, int n, int qscale)
251 {
252 int i, level, nCoeffs;
253 const uint16_t *quant_matrix;
254 int sum=-1;
255
256 if(s->alternate_scan) nCoeffs= 63;
257 else nCoeffs= s->block_last_index[n];
258
259 quant_matrix = s->inter_matrix;
260 for(i=0; i<=nCoeffs; i++) {
261 int j= s->intra_scantable.permutated[i];
262 level = block[j];
263 if (level) {
264 if (level < 0) {
265 level = -level;
266 level = (((level << 1) + 1) * qscale *
267 ((int) (quant_matrix[j]))) >> 4;
268 level = -level;
269 } else {
270 level = (((level << 1) + 1) * qscale *
271 ((int) (quant_matrix[j]))) >> 4;
272 }
273 block[j] = level;
274 sum+=level;
275 }
276 }
277 block[63]^=sum&1;
278 }
279
dct_unquantize_h263_intra_c(MpegEncContext * s,int16_t * block,int n,int qscale)280 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
281 int16_t *block, int n, int qscale)
282 {
283 int i, level, qmul, qadd;
284 int nCoeffs;
285
286 av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
287
288 qmul = qscale << 1;
289
290 if (!s->h263_aic) {
291 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
292 qadd = (qscale - 1) | 1;
293 }else{
294 qadd = 0;
295 }
296 if(s->ac_pred)
297 nCoeffs=63;
298 else
299 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
300
301 for(i=1; i<=nCoeffs; i++) {
302 level = block[i];
303 if (level) {
304 if (level < 0) {
305 level = level * qmul - qadd;
306 } else {
307 level = level * qmul + qadd;
308 }
309 block[i] = level;
310 }
311 }
312 }
313
dct_unquantize_h263_inter_c(MpegEncContext * s,int16_t * block,int n,int qscale)314 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
315 int16_t *block, int n, int qscale)
316 {
317 int i, level, qmul, qadd;
318 int nCoeffs;
319
320 av_assert2(s->block_last_index[n]>=0);
321
322 qadd = (qscale - 1) | 1;
323 qmul = qscale << 1;
324
325 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
326
327 for(i=0; i<=nCoeffs; i++) {
328 level = block[i];
329 if (level) {
330 if (level < 0) {
331 level = level * qmul - qadd;
332 } else {
333 level = level * qmul + qadd;
334 }
335 block[i] = level;
336 }
337 }
338 }
339
mpeg_er_decode_mb(void * opaque,int ref,int mv_dir,int mv_type,int (* mv)[2][4][2],int mb_x,int mb_y,int mb_intra,int mb_skipped)340 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
341 int (*mv)[2][4][2],
342 int mb_x, int mb_y, int mb_intra, int mb_skipped)
343 {
344 MpegEncContext *s = opaque;
345
346 s->mv_dir = mv_dir;
347 s->mv_type = mv_type;
348 s->mb_intra = mb_intra;
349 s->mb_skipped = mb_skipped;
350 s->mb_x = mb_x;
351 s->mb_y = mb_y;
352 memcpy(s->mv, mv, sizeof(*mv));
353
354 ff_init_block_index(s);
355 ff_update_block_index(s);
356
357 s->bdsp.clear_blocks(s->block[0]);
358
359 s->dest[0] = s->current_picture.f->data[0] + (s->mb_y * 16 * s->linesize) + s->mb_x * 16;
360 s->dest[1] = s->current_picture.f->data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
361 s->dest[2] = s->current_picture.f->data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
362
363 if (ref)
364 av_log(s->avctx, AV_LOG_DEBUG, "Interlaced error concealment is not fully implemented\n");
365 ff_mpv_decode_mb(s, s->block);
366 }
367
gray16(uint8_t * dst,const uint8_t * src,ptrdiff_t linesize,int h)368 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
369 {
370 while(h--)
371 memset(dst + h*linesize, 128, 16);
372 }
373
gray8(uint8_t * dst,const uint8_t * src,ptrdiff_t linesize,int h)374 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
375 {
376 while(h--)
377 memset(dst + h*linesize, 128, 8);
378 }
379
380 /* init common dct for both encoder and decoder */
dct_init(MpegEncContext * s)381 static av_cold int dct_init(MpegEncContext *s)
382 {
383 ff_blockdsp_init(&s->bdsp, s->avctx);
384 ff_h264chroma_init(&s->h264chroma, 8); //for lowres
385 ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
386 ff_me_cmp_init(&s->mecc, s->avctx);
387 ff_mpegvideodsp_init(&s->mdsp);
388 ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
389
390 if (s->avctx->debug & FF_DEBUG_NOMC) {
391 int i;
392 for (i=0; i<4; i++) {
393 s->hdsp.avg_pixels_tab[0][i] = gray16;
394 s->hdsp.put_pixels_tab[0][i] = gray16;
395 s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
396
397 s->hdsp.avg_pixels_tab[1][i] = gray8;
398 s->hdsp.put_pixels_tab[1][i] = gray8;
399 s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
400 }
401 }
402
403 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
404 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
405 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
406 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
407 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
408 if (s->flags & CODEC_FLAG_BITEXACT)
409 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
410 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
411
412 #if (HAVE_INTRINSICS_NEON == 1)
413 if (HAVE_INTRINSICS_NEON)
414 ff_mpv_common_init_neon(s);
415 #endif
416
417 #if (ARCH_ALPHA == 1)
418 if (ARCH_ALPHA)
419 ff_mpv_common_init_axp(s);
420 #endif
421 #if (ARCH_ARM == 1)
422 if (ARCH_ARM)
423 ff_mpv_common_init_arm(s);
424 #endif
425 #if (ARCH_PPC == 1)
426 if (ARCH_PPC)
427 ff_mpv_common_init_ppc(s);
428 #endif
429 #if (ARCH_X86 == 1)
430 if (ARCH_X86)
431 ff_mpv_common_init_x86(s);
432 #endif
433
434 return 0;
435 }
436
ff_mpv_idct_init(MpegEncContext * s)437 av_cold void ff_mpv_idct_init(MpegEncContext *s)
438 {
439 ff_idctdsp_init(&s->idsp, s->avctx);
440
441 /* load & permutate scantables
442 * note: only wmv uses different ones
443 */
444 if (s->alternate_scan) {
445 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
446 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
447 } else {
448 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
449 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
450 }
451 ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
452 ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
453 }
454
frame_size_alloc(MpegEncContext * s,int linesize)455 static int frame_size_alloc(MpegEncContext *s, int linesize)
456 {
457 int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
458
459 if (s->avctx->hwaccel || s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
460 return 0;
461
462 if (linesize < 24) {
463 av_log(s->avctx, AV_LOG_ERROR, "Image too small, temporary buffers cannot function\n");
464 return AVERROR_PATCHWELCOME;
465 }
466
467 // edge emu needs blocksize + filter length - 1
468 // (= 17x17 for halfpel / 21x21 for h264)
469 // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
470 // at uvlinesize. It supports only YUV420 so 24x24 is enough
471 // linesize * interlaced * MBsize
472 // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines
473 FF_ALLOCZ_ARRAY_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size, 4 * 68,
474 fail);
475
476 FF_ALLOCZ_ARRAY_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size, 4 * 16 * 2,
477 fail)
478 s->me.temp = s->me.scratchpad;
479 s->rd_scratchpad = s->me.scratchpad;
480 s->b_scratchpad = s->me.scratchpad;
481 s->obmc_scratchpad = s->me.scratchpad + 16;
482
483 return 0;
484 fail:
485 av_freep(&s->edge_emu_buffer);
486 return AVERROR(ENOMEM);
487 }
488
489 /**
490 * Allocate a frame buffer
491 */
alloc_frame_buffer(MpegEncContext * s,Picture * pic)492 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
493 {
494 int edges_needed = av_codec_is_encoder(s->avctx->codec);
495 int r, ret;
496
497 pic->tf.f = pic->f;
498 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
499 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
500 s->codec_id != AV_CODEC_ID_MSS2) {
501 if (edges_needed) {
502 pic->f->width = s->avctx->width + 2 * EDGE_WIDTH;
503 pic->f->height = s->avctx->height + 2 * EDGE_WIDTH;
504 }
505
506 r = ff_thread_get_buffer(s->avctx, &pic->tf,
507 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
508 } else {
509 pic->f->width = s->avctx->width;
510 pic->f->height = s->avctx->height;
511 pic->f->format = s->avctx->pix_fmt;
512 r = avcodec_default_get_buffer2(s->avctx, pic->f, 0);
513 }
514
515 if (r < 0 || !pic->f->buf[0]) {
516 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
517 r, pic->f->data[0]);
518 return -1;
519 }
520
521 if (edges_needed) {
522 int i;
523 for (i = 0; pic->f->data[i]; i++) {
524 int offset = (EDGE_WIDTH >> (i ? s->chroma_y_shift : 0)) *
525 pic->f->linesize[i] +
526 (EDGE_WIDTH >> (i ? s->chroma_x_shift : 0));
527 pic->f->data[i] += offset;
528 }
529 pic->f->width = s->avctx->width;
530 pic->f->height = s->avctx->height;
531 }
532
533 if (s->avctx->hwaccel) {
534 assert(!pic->hwaccel_picture_private);
535 if (s->avctx->hwaccel->frame_priv_data_size) {
536 pic->hwaccel_priv_buf = av_buffer_allocz(s->avctx->hwaccel->frame_priv_data_size);
537 if (!pic->hwaccel_priv_buf) {
538 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
539 return -1;
540 }
541 pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
542 }
543 }
544
545 if (s->linesize && (s->linesize != pic->f->linesize[0] ||
546 s->uvlinesize != pic->f->linesize[1])) {
547 av_log(s->avctx, AV_LOG_ERROR,
548 "get_buffer() failed (stride changed)\n");
549 ff_mpeg_unref_picture(s, pic);
550 return -1;
551 }
552
553 if (pic->f->linesize[1] != pic->f->linesize[2]) {
554 av_log(s->avctx, AV_LOG_ERROR,
555 "get_buffer() failed (uv stride mismatch)\n");
556 ff_mpeg_unref_picture(s, pic);
557 return -1;
558 }
559
560 if (!s->edge_emu_buffer &&
561 (ret = frame_size_alloc(s, pic->f->linesize[0])) < 0) {
562 av_log(s->avctx, AV_LOG_ERROR,
563 "get_buffer() failed to allocate context scratch buffers.\n");
564 ff_mpeg_unref_picture(s, pic);
565 return ret;
566 }
567
568 return 0;
569 }
570
ff_free_picture_tables(Picture * pic)571 void ff_free_picture_tables(Picture *pic)
572 {
573 int i;
574
575 pic->alloc_mb_width =
576 pic->alloc_mb_height = 0;
577
578 av_buffer_unref(&pic->mb_var_buf);
579 av_buffer_unref(&pic->mc_mb_var_buf);
580 av_buffer_unref(&pic->mb_mean_buf);
581 av_buffer_unref(&pic->mbskip_table_buf);
582 av_buffer_unref(&pic->qscale_table_buf);
583 av_buffer_unref(&pic->mb_type_buf);
584
585 for (i = 0; i < 2; i++) {
586 av_buffer_unref(&pic->motion_val_buf[i]);
587 av_buffer_unref(&pic->ref_index_buf[i]);
588 }
589 }
590
alloc_picture_tables(MpegEncContext * s,Picture * pic)591 static int alloc_picture_tables(MpegEncContext *s, Picture *pic)
592 {
593 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
594 const int mb_array_size = s->mb_stride * s->mb_height;
595 const int b8_array_size = s->b8_stride * s->mb_height * 2;
596 int i;
597
598
599 pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
600 pic->qscale_table_buf = av_buffer_allocz(big_mb_num + s->mb_stride);
601 pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) *
602 sizeof(uint32_t));
603 if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
604 return AVERROR(ENOMEM);
605
606 if (s->encoding) {
607 pic->mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
608 pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
609 pic->mb_mean_buf = av_buffer_allocz(mb_array_size);
610 if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
611 return AVERROR(ENOMEM);
612 }
613
614 if (s->out_format == FMT_H263 || s->encoding || s->avctx->debug_mv ||
615 (s->avctx->flags2 & CODEC_FLAG2_EXPORT_MVS)) {
616 int mv_size = 2 * (b8_array_size + 4) * sizeof(int16_t);
617 int ref_index_size = 4 * mb_array_size;
618
619 for (i = 0; mv_size && i < 2; i++) {
620 pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
621 pic->ref_index_buf[i] = av_buffer_allocz(ref_index_size);
622 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
623 return AVERROR(ENOMEM);
624 }
625 }
626
627 pic->alloc_mb_width = s->mb_width;
628 pic->alloc_mb_height = s->mb_height;
629
630 return 0;
631 }
632
make_tables_writable(Picture * pic)633 static int make_tables_writable(Picture *pic)
634 {
635 int ret, i;
636 #define MAKE_WRITABLE(table) \
637 do {\
638 if (pic->table &&\
639 (ret = av_buffer_make_writable(&pic->table)) < 0)\
640 return ret;\
641 } while (0)
642
643 MAKE_WRITABLE(mb_var_buf);
644 MAKE_WRITABLE(mc_mb_var_buf);
645 MAKE_WRITABLE(mb_mean_buf);
646 MAKE_WRITABLE(mbskip_table_buf);
647 MAKE_WRITABLE(qscale_table_buf);
648 MAKE_WRITABLE(mb_type_buf);
649
650 for (i = 0; i < 2; i++) {
651 MAKE_WRITABLE(motion_val_buf[i]);
652 MAKE_WRITABLE(ref_index_buf[i]);
653 }
654
655 return 0;
656 }
657
658 /**
659 * Allocate a Picture.
660 * The pixels are allocated/set by calling get_buffer() if shared = 0
661 */
ff_alloc_picture(MpegEncContext * s,Picture * pic,int shared)662 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
663 {
664 int i, ret;
665
666 if (pic->qscale_table_buf)
667 if ( pic->alloc_mb_width != s->mb_width
668 || pic->alloc_mb_height != s->mb_height)
669 ff_free_picture_tables(pic);
670
671 if (shared) {
672 av_assert0(pic->f->data[0]);
673 pic->shared = 1;
674 } else {
675 av_assert0(!pic->f->buf[0]);
676
677 if (alloc_frame_buffer(s, pic) < 0)
678 return -1;
679
680 s->linesize = pic->f->linesize[0];
681 s->uvlinesize = pic->f->linesize[1];
682 }
683
684 if (!pic->qscale_table_buf)
685 ret = alloc_picture_tables(s, pic);
686 else
687 ret = make_tables_writable(pic);
688 if (ret < 0)
689 goto fail;
690
691 if (s->encoding) {
692 pic->mb_var = (uint16_t*)pic->mb_var_buf->data;
693 pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
694 pic->mb_mean = pic->mb_mean_buf->data;
695 }
696
697 pic->mbskip_table = pic->mbskip_table_buf->data;
698 pic->qscale_table = pic->qscale_table_buf->data + 2 * s->mb_stride + 1;
699 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
700
701 if (pic->motion_val_buf[0]) {
702 for (i = 0; i < 2; i++) {
703 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
704 pic->ref_index[i] = pic->ref_index_buf[i]->data;
705 }
706 }
707
708 return 0;
709 fail:
710 av_log(s->avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
711 ff_mpeg_unref_picture(s, pic);
712 ff_free_picture_tables(pic);
713 return AVERROR(ENOMEM);
714 }
715
716 /**
717 * Deallocate a picture.
718 */
ff_mpeg_unref_picture(MpegEncContext * s,Picture * pic)719 void ff_mpeg_unref_picture(MpegEncContext *s, Picture *pic)
720 {
721 int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
722
723 pic->tf.f = pic->f;
724 /* WM Image / Screen codecs allocate internal buffers with different
725 * dimensions / colorspaces; ignore user-defined callbacks for these. */
726 if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
727 s->codec_id != AV_CODEC_ID_VC1IMAGE &&
728 s->codec_id != AV_CODEC_ID_MSS2)
729 ff_thread_release_buffer(s->avctx, &pic->tf);
730 else if (pic->f)
731 av_frame_unref(pic->f);
732
733 av_buffer_unref(&pic->hwaccel_priv_buf);
734
735 if (pic->needs_realloc)
736 ff_free_picture_tables(pic);
737
738 memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
739 }
740
update_picture_tables(Picture * dst,Picture * src)741 static int update_picture_tables(Picture *dst, Picture *src)
742 {
743 int i;
744
745 #define UPDATE_TABLE(table)\
746 do {\
747 if (src->table &&\
748 (!dst->table || dst->table->buffer != src->table->buffer)) {\
749 av_buffer_unref(&dst->table);\
750 dst->table = av_buffer_ref(src->table);\
751 if (!dst->table) {\
752 ff_free_picture_tables(dst);\
753 return AVERROR(ENOMEM);\
754 }\
755 }\
756 } while (0)
757
758 UPDATE_TABLE(mb_var_buf);
759 UPDATE_TABLE(mc_mb_var_buf);
760 UPDATE_TABLE(mb_mean_buf);
761 UPDATE_TABLE(mbskip_table_buf);
762 UPDATE_TABLE(qscale_table_buf);
763 UPDATE_TABLE(mb_type_buf);
764 for (i = 0; i < 2; i++) {
765 UPDATE_TABLE(motion_val_buf[i]);
766 UPDATE_TABLE(ref_index_buf[i]);
767 }
768
769 dst->mb_var = src->mb_var;
770 dst->mc_mb_var = src->mc_mb_var;
771 dst->mb_mean = src->mb_mean;
772 dst->mbskip_table = src->mbskip_table;
773 dst->qscale_table = src->qscale_table;
774 dst->mb_type = src->mb_type;
775 for (i = 0; i < 2; i++) {
776 dst->motion_val[i] = src->motion_val[i];
777 dst->ref_index[i] = src->ref_index[i];
778 }
779
780 dst->alloc_mb_width = src->alloc_mb_width;
781 dst->alloc_mb_height = src->alloc_mb_height;
782
783 return 0;
784 }
785
ff_mpeg_ref_picture(MpegEncContext * s,Picture * dst,Picture * src)786 int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src)
787 {
788 int ret;
789
790 av_assert0(!dst->f->buf[0]);
791 av_assert0(src->f->buf[0]);
792
793 src->tf.f = src->f;
794 dst->tf.f = dst->f;
795 ret = ff_thread_ref_frame(&dst->tf, &src->tf);
796 if (ret < 0)
797 goto fail;
798
799 ret = update_picture_tables(dst, src);
800 if (ret < 0)
801 goto fail;
802
803 if (src->hwaccel_picture_private) {
804 dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
805 if (!dst->hwaccel_priv_buf)
806 goto fail;
807 dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
808 }
809
810 dst->field_picture = src->field_picture;
811 dst->mb_var_sum = src->mb_var_sum;
812 dst->mc_mb_var_sum = src->mc_mb_var_sum;
813 dst->b_frame_score = src->b_frame_score;
814 dst->needs_realloc = src->needs_realloc;
815 dst->reference = src->reference;
816 dst->shared = src->shared;
817
818 return 0;
819 fail:
820 ff_mpeg_unref_picture(s, dst);
821 return ret;
822 }
823
exchange_uv(MpegEncContext * s)824 static void exchange_uv(MpegEncContext *s)
825 {
826 int16_t (*tmp)[64];
827
828 tmp = s->pblocks[4];
829 s->pblocks[4] = s->pblocks[5];
830 s->pblocks[5] = tmp;
831 }
832
init_duplicate_context(MpegEncContext * s)833 static int init_duplicate_context(MpegEncContext *s)
834 {
835 int y_size = s->b8_stride * (2 * s->mb_height + 1);
836 int c_size = s->mb_stride * (s->mb_height + 1);
837 int yc_size = y_size + 2 * c_size;
838 int i;
839
840 if (s->mb_height & 1)
841 yc_size += 2*s->b8_stride + 2*s->mb_stride;
842
843 s->edge_emu_buffer =
844 s->me.scratchpad =
845 s->me.temp =
846 s->rd_scratchpad =
847 s->b_scratchpad =
848 s->obmc_scratchpad = NULL;
849
850 if (s->encoding) {
851 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
852 ME_MAP_SIZE * sizeof(uint32_t), fail)
853 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
854 ME_MAP_SIZE * sizeof(uint32_t), fail)
855 if (s->avctx->noise_reduction) {
856 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
857 2 * 64 * sizeof(int), fail)
858 }
859 }
860 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
861 s->block = s->blocks[0];
862
863 for (i = 0; i < 12; i++) {
864 s->pblocks[i] = &s->block[i];
865 }
866 if (s->avctx->codec_tag == AV_RL32("VCR2"))
867 exchange_uv(s);
868
869 if (s->out_format == FMT_H263) {
870 /* ac values */
871 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
872 yc_size * sizeof(int16_t) * 16, fail);
873 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
874 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
875 s->ac_val[2] = s->ac_val[1] + c_size;
876 }
877
878 return 0;
879 fail:
880 return -1; // free() through ff_mpv_common_end()
881 }
882
free_duplicate_context(MpegEncContext * s)883 static void free_duplicate_context(MpegEncContext *s)
884 {
885 if (!s)
886 return;
887
888 av_freep(&s->edge_emu_buffer);
889 av_freep(&s->me.scratchpad);
890 s->me.temp =
891 s->rd_scratchpad =
892 s->b_scratchpad =
893 s->obmc_scratchpad = NULL;
894
895 av_freep(&s->dct_error_sum);
896 av_freep(&s->me.map);
897 av_freep(&s->me.score_map);
898 av_freep(&s->blocks);
899 av_freep(&s->ac_val_base);
900 s->block = NULL;
901 }
902
backup_duplicate_context(MpegEncContext * bak,MpegEncContext * src)903 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
904 {
905 #define COPY(a) bak->a = src->a
906 COPY(edge_emu_buffer);
907 COPY(me.scratchpad);
908 COPY(me.temp);
909 COPY(rd_scratchpad);
910 COPY(b_scratchpad);
911 COPY(obmc_scratchpad);
912 COPY(me.map);
913 COPY(me.score_map);
914 COPY(blocks);
915 COPY(block);
916 COPY(start_mb_y);
917 COPY(end_mb_y);
918 COPY(me.map_generation);
919 COPY(pb);
920 COPY(dct_error_sum);
921 COPY(dct_count[0]);
922 COPY(dct_count[1]);
923 COPY(ac_val_base);
924 COPY(ac_val[0]);
925 COPY(ac_val[1]);
926 COPY(ac_val[2]);
927 #undef COPY
928 }
929
ff_update_duplicate_context(MpegEncContext * dst,MpegEncContext * src)930 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
931 {
932 MpegEncContext bak;
933 int i, ret;
934 // FIXME copy only needed parts
935 // START_TIMER
936 backup_duplicate_context(&bak, dst);
937 memcpy(dst, src, sizeof(MpegEncContext));
938 backup_duplicate_context(dst, &bak);
939 for (i = 0; i < 12; i++) {
940 dst->pblocks[i] = &dst->block[i];
941 }
942 if (dst->avctx->codec_tag == AV_RL32("VCR2"))
943 exchange_uv(dst);
944 if (!dst->edge_emu_buffer &&
945 (ret = frame_size_alloc(dst, dst->linesize)) < 0) {
946 av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
947 "scratch buffers.\n");
948 return ret;
949 }
950 // STOP_TIMER("update_duplicate_context")
951 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
952 return 0;
953 }
954
ff_mpeg_update_thread_context(AVCodecContext * dst,const AVCodecContext * src)955 int ff_mpeg_update_thread_context(AVCodecContext *dst,
956 const AVCodecContext *src)
957 {
958 int i, ret;
959 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
960
961 if (dst == src)
962 return 0;
963
964 av_assert0(s != s1);
965
966 // FIXME can parameters change on I-frames?
967 // in that case dst may need a reinit
968 if (!s->context_initialized) {
969 memcpy(s, s1, sizeof(MpegEncContext));
970
971 s->avctx = dst;
972 s->bitstream_buffer = NULL;
973 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
974
975 if (s1->context_initialized){
976 // s->picture_range_start += MAX_PICTURE_COUNT;
977 // s->picture_range_end += MAX_PICTURE_COUNT;
978 ff_mpv_idct_init(s);
979 if((ret = ff_mpv_common_init(s)) < 0){
980 memset(s, 0, sizeof(MpegEncContext));
981 s->avctx = dst;
982 return ret;
983 }
984 }
985 }
986
987 if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
988 s->context_reinit = 0;
989 s->height = s1->height;
990 s->width = s1->width;
991 if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
992 return ret;
993 }
994
995 s->avctx->coded_height = s1->avctx->coded_height;
996 s->avctx->coded_width = s1->avctx->coded_width;
997 s->avctx->width = s1->avctx->width;
998 s->avctx->height = s1->avctx->height;
999
1000 s->coded_picture_number = s1->coded_picture_number;
1001 s->picture_number = s1->picture_number;
1002
1003 av_assert0(!s->picture || s->picture != s1->picture);
1004 if(s->picture)
1005 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1006 ff_mpeg_unref_picture(s, &s->picture[i]);
1007 if (s1->picture[i].f->buf[0] &&
1008 (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
1009 return ret;
1010 }
1011
1012 #define UPDATE_PICTURE(pic)\
1013 do {\
1014 ff_mpeg_unref_picture(s, &s->pic);\
1015 if (s1->pic.f && s1->pic.f->buf[0])\
1016 ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
1017 else\
1018 ret = update_picture_tables(&s->pic, &s1->pic);\
1019 if (ret < 0)\
1020 return ret;\
1021 } while (0)
1022
1023 UPDATE_PICTURE(current_picture);
1024 UPDATE_PICTURE(last_picture);
1025 UPDATE_PICTURE(next_picture);
1026
1027 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
1028 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
1029 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
1030
1031 // Error/bug resilience
1032 s->next_p_frame_damaged = s1->next_p_frame_damaged;
1033 s->workaround_bugs = s1->workaround_bugs;
1034 s->padding_bug_score = s1->padding_bug_score;
1035
1036 // MPEG4 timing info
1037 memcpy(&s->last_time_base, &s1->last_time_base,
1038 (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
1039 (char *) &s1->last_time_base);
1040
1041 // B-frame info
1042 s->max_b_frames = s1->max_b_frames;
1043 s->low_delay = s1->low_delay;
1044 s->droppable = s1->droppable;
1045
1046 // DivX handling (doesn't work)
1047 s->divx_packed = s1->divx_packed;
1048
1049 if (s1->bitstream_buffer) {
1050 if (s1->bitstream_buffer_size +
1051 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
1052 av_fast_malloc(&s->bitstream_buffer,
1053 &s->allocated_bitstream_buffer_size,
1054 s1->allocated_bitstream_buffer_size);
1055 s->bitstream_buffer_size = s1->bitstream_buffer_size;
1056 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
1057 s1->bitstream_buffer_size);
1058 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
1059 FF_INPUT_BUFFER_PADDING_SIZE);
1060 }
1061
1062 // linesize dependend scratch buffer allocation
1063 if (!s->edge_emu_buffer)
1064 if (s1->linesize) {
1065 if (frame_size_alloc(s, s1->linesize) < 0) {
1066 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
1067 "scratch buffers.\n");
1068 return AVERROR(ENOMEM);
1069 }
1070 } else {
1071 av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
1072 "be allocated due to unknown size.\n");
1073 }
1074
1075 // MPEG2/interlacing info
1076 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
1077 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
1078
1079 if (!s1->first_field) {
1080 s->last_pict_type = s1->pict_type;
1081 if (s1->current_picture_ptr)
1082 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
1083 }
1084
1085 return 0;
1086 }
1087
1088 /**
1089 * Set the given MpegEncContext to common defaults
1090 * (same for encoding and decoding).
1091 * The changed fields will not depend upon the
1092 * prior state of the MpegEncContext.
1093 */
ff_mpv_common_defaults(MpegEncContext * s)1094 void ff_mpv_common_defaults(MpegEncContext *s)
1095 {
1096 s->y_dc_scale_table =
1097 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
1098 s->chroma_qscale_table = ff_default_chroma_qscale_table;
1099 s->progressive_frame = 1;
1100 s->progressive_sequence = 1;
1101 s->picture_structure = PICT_FRAME;
1102
1103 s->coded_picture_number = 0;
1104 s->picture_number = 0;
1105
1106 s->f_code = 1;
1107 s->b_code = 1;
1108
1109 s->slice_context_count = 1;
1110 }
1111
1112 /**
1113 * Set the given MpegEncContext to defaults for decoding.
1114 * the changed fields will not depend upon
1115 * the prior state of the MpegEncContext.
1116 */
ff_mpv_decode_defaults(MpegEncContext * s)1117 void ff_mpv_decode_defaults(MpegEncContext *s)
1118 {
1119 ff_mpv_common_defaults(s);
1120 }
1121
ff_mpv_decode_init(MpegEncContext * s,AVCodecContext * avctx)1122 void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
1123 {
1124 s->avctx = avctx;
1125 s->width = avctx->coded_width;
1126 s->height = avctx->coded_height;
1127 s->codec_id = avctx->codec->id;
1128 s->workaround_bugs = avctx->workaround_bugs;
1129 s->flags = avctx->flags;
1130 s->flags2 = avctx->flags2;
1131
1132 /* convert fourcc to upper case */
1133 s->codec_tag = avpriv_toupper4(avctx->codec_tag);
1134
1135 s->stream_codec_tag = avpriv_toupper4(avctx->stream_codec_tag);
1136 }
1137
init_er(MpegEncContext * s)1138 static int init_er(MpegEncContext *s)
1139 {
1140 ERContext *er = &s->er;
1141 int mb_array_size = s->mb_height * s->mb_stride;
1142 int i;
1143
1144 er->avctx = s->avctx;
1145 er->mecc = &s->mecc;
1146
1147 er->mb_index2xy = s->mb_index2xy;
1148 er->mb_num = s->mb_num;
1149 er->mb_width = s->mb_width;
1150 er->mb_height = s->mb_height;
1151 er->mb_stride = s->mb_stride;
1152 er->b8_stride = s->b8_stride;
1153
1154 er->er_temp_buffer = av_malloc(s->mb_height * s->mb_stride);
1155 er->error_status_table = av_mallocz(mb_array_size);
1156 if (!er->er_temp_buffer || !er->error_status_table)
1157 goto fail;
1158
1159 er->mbskip_table = s->mbskip_table;
1160 er->mbintra_table = s->mbintra_table;
1161
1162 for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
1163 er->dc_val[i] = s->dc_val[i];
1164
1165 er->decode_mb = mpeg_er_decode_mb;
1166 er->opaque = s;
1167
1168 return 0;
1169 fail:
1170 av_freep(&er->er_temp_buffer);
1171 av_freep(&er->error_status_table);
1172 return AVERROR(ENOMEM);
1173 }
1174
1175 /**
1176 * Initialize and allocates MpegEncContext fields dependent on the resolution.
1177 */
init_context_frame(MpegEncContext * s)1178 static int init_context_frame(MpegEncContext *s)
1179 {
1180 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
1181
1182 s->mb_width = (s->width + 15) / 16;
1183 s->mb_stride = s->mb_width + 1;
1184 s->b8_stride = s->mb_width * 2 + 1;
1185 mb_array_size = s->mb_height * s->mb_stride;
1186 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
1187
1188 /* set default edge pos, will be overridden
1189 * in decode_header if needed */
1190 s->h_edge_pos = s->mb_width * 16;
1191 s->v_edge_pos = s->mb_height * 16;
1192
1193 s->mb_num = s->mb_width * s->mb_height;
1194
1195 s->block_wrap[0] =
1196 s->block_wrap[1] =
1197 s->block_wrap[2] =
1198 s->block_wrap[3] = s->b8_stride;
1199 s->block_wrap[4] =
1200 s->block_wrap[5] = s->mb_stride;
1201
1202 y_size = s->b8_stride * (2 * s->mb_height + 1);
1203 c_size = s->mb_stride * (s->mb_height + 1);
1204 yc_size = y_size + 2 * c_size;
1205
1206 if (s->mb_height & 1)
1207 yc_size += 2*s->b8_stride + 2*s->mb_stride;
1208
1209 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
1210 for (y = 0; y < s->mb_height; y++)
1211 for (x = 0; x < s->mb_width; x++)
1212 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
1213
1214 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
1215
1216 if (s->encoding) {
1217 /* Allocate MV tables */
1218 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1219 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1220 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1221 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1222 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1223 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base, mv_table_size * 2 * sizeof(int16_t), fail)
1224 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
1225 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
1226 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
1227 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
1228 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
1229 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
1230
1231 /* Allocate MB type table */
1232 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
1233
1234 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
1235
1236 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
1237 mb_array_size * sizeof(float), fail);
1238 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
1239 mb_array_size * sizeof(float), fail);
1240
1241 }
1242
1243 if (s->codec_id == AV_CODEC_ID_MPEG4 ||
1244 (s->flags & CODEC_FLAG_INTERLACED_ME)) {
1245 /* interlaced direct mode decoding tables */
1246 for (i = 0; i < 2; i++) {
1247 int j, k;
1248 for (j = 0; j < 2; j++) {
1249 for (k = 0; k < 2; k++) {
1250 FF_ALLOCZ_OR_GOTO(s->avctx,
1251 s->b_field_mv_table_base[i][j][k],
1252 mv_table_size * 2 * sizeof(int16_t),
1253 fail);
1254 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
1255 s->mb_stride + 1;
1256 }
1257 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
1258 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
1259 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
1260 }
1261 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
1262 }
1263 }
1264 if (s->out_format == FMT_H263) {
1265 /* cbp values */
1266 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
1267 s->coded_block = s->coded_block_base + s->b8_stride + 1;
1268
1269 /* cbp, ac_pred, pred_dir */
1270 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
1271 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
1272 }
1273
1274 if (s->h263_pred || s->h263_plus || !s->encoding) {
1275 /* dc values */
1276 // MN: we need these for error resilience of intra-frames
1277 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
1278 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
1279 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
1280 s->dc_val[2] = s->dc_val[1] + c_size;
1281 for (i = 0; i < yc_size; i++)
1282 s->dc_val_base[i] = 1024;
1283 }
1284
1285 /* which mb is a intra block */
1286 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
1287 memset(s->mbintra_table, 1, mb_array_size);
1288
1289 /* init macroblock skip table */
1290 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
1291 // Note the + 1 is for a quicker mpeg4 slice_end detection
1292
1293 return init_er(s);
1294 fail:
1295 return AVERROR(ENOMEM);
1296 }
1297
1298 /**
1299 * init common structure for both encoder and decoder.
1300 * this assumes that some variables like width/height are already set
1301 */
ff_mpv_common_init(MpegEncContext * s)1302 av_cold int ff_mpv_common_init(MpegEncContext *s)
1303 {
1304 int i;
1305 int nb_slices = (HAVE_THREADS &&
1306 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
1307 s->avctx->thread_count : 1;
1308
1309 if (s->encoding && s->avctx->slices)
1310 nb_slices = s->avctx->slices;
1311
1312 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1313 s->mb_height = (s->height + 31) / 32 * 2;
1314 else
1315 s->mb_height = (s->height + 15) / 16;
1316
1317 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1318 av_log(s->avctx, AV_LOG_ERROR,
1319 "decoding to AV_PIX_FMT_NONE is not supported.\n");
1320 return -1;
1321 }
1322
1323 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1324 int max_slices;
1325 if (s->mb_height)
1326 max_slices = FFMIN(MAX_THREADS, s->mb_height);
1327 else
1328 max_slices = MAX_THREADS;
1329 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1330 " reducing to %d\n", nb_slices, max_slices);
1331 nb_slices = max_slices;
1332 }
1333
1334 if ((s->width || s->height) &&
1335 av_image_check_size(s->width, s->height, 0, s->avctx))
1336 return -1;
1337
1338 dct_init(s);
1339
1340 s->flags = s->avctx->flags;
1341 s->flags2 = s->avctx->flags2;
1342
1343 /* set chroma shifts */
1344 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1345 &s->chroma_x_shift,
1346 &s->chroma_y_shift);
1347
1348
1349 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1350 MAX_PICTURE_COUNT * sizeof(Picture), fail);
1351 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1352 s->picture[i].f = av_frame_alloc();
1353 if (!s->picture[i].f)
1354 goto fail;
1355 }
1356 memset(&s->next_picture, 0, sizeof(s->next_picture));
1357 memset(&s->last_picture, 0, sizeof(s->last_picture));
1358 memset(&s->current_picture, 0, sizeof(s->current_picture));
1359 memset(&s->new_picture, 0, sizeof(s->new_picture));
1360 s->next_picture.f = av_frame_alloc();
1361 if (!s->next_picture.f)
1362 goto fail;
1363 s->last_picture.f = av_frame_alloc();
1364 if (!s->last_picture.f)
1365 goto fail;
1366 s->current_picture.f = av_frame_alloc();
1367 if (!s->current_picture.f)
1368 goto fail;
1369 s->new_picture.f = av_frame_alloc();
1370 if (!s->new_picture.f)
1371 goto fail;
1372
1373 if (init_context_frame(s))
1374 goto fail;
1375
1376 s->parse_context.state = -1;
1377
1378 s->context_initialized = 1;
1379 s->thread_context[0] = s;
1380
1381 // if (s->width && s->height) {
1382 if (nb_slices > 1) {
1383 for (i = 1; i < nb_slices; i++) {
1384 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1385 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1386 }
1387
1388 for (i = 0; i < nb_slices; i++) {
1389 if (init_duplicate_context(s->thread_context[i]) < 0)
1390 goto fail;
1391 s->thread_context[i]->start_mb_y =
1392 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1393 s->thread_context[i]->end_mb_y =
1394 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1395 }
1396 } else {
1397 if (init_duplicate_context(s) < 0)
1398 goto fail;
1399 s->start_mb_y = 0;
1400 s->end_mb_y = s->mb_height;
1401 }
1402 s->slice_context_count = nb_slices;
1403 // }
1404
1405 return 0;
1406 fail:
1407 ff_mpv_common_end(s);
1408 return -1;
1409 }
1410
1411 /**
1412 * Frees and resets MpegEncContext fields depending on the resolution.
1413 * Is used during resolution changes to avoid a full reinitialization of the
1414 * codec.
1415 */
free_context_frame(MpegEncContext * s)1416 static void free_context_frame(MpegEncContext *s)
1417 {
1418 int i, j, k;
1419
1420 av_freep(&s->mb_type);
1421 av_freep(&s->p_mv_table_base);
1422 av_freep(&s->b_forw_mv_table_base);
1423 av_freep(&s->b_back_mv_table_base);
1424 av_freep(&s->b_bidir_forw_mv_table_base);
1425 av_freep(&s->b_bidir_back_mv_table_base);
1426 av_freep(&s->b_direct_mv_table_base);
1427 s->p_mv_table = NULL;
1428 s->b_forw_mv_table = NULL;
1429 s->b_back_mv_table = NULL;
1430 s->b_bidir_forw_mv_table = NULL;
1431 s->b_bidir_back_mv_table = NULL;
1432 s->b_direct_mv_table = NULL;
1433 for (i = 0; i < 2; i++) {
1434 for (j = 0; j < 2; j++) {
1435 for (k = 0; k < 2; k++) {
1436 av_freep(&s->b_field_mv_table_base[i][j][k]);
1437 s->b_field_mv_table[i][j][k] = NULL;
1438 }
1439 av_freep(&s->b_field_select_table[i][j]);
1440 av_freep(&s->p_field_mv_table_base[i][j]);
1441 s->p_field_mv_table[i][j] = NULL;
1442 }
1443 av_freep(&s->p_field_select_table[i]);
1444 }
1445
1446 av_freep(&s->dc_val_base);
1447 av_freep(&s->coded_block_base);
1448 av_freep(&s->mbintra_table);
1449 av_freep(&s->cbp_table);
1450 av_freep(&s->pred_dir_table);
1451
1452 av_freep(&s->mbskip_table);
1453
1454 av_freep(&s->er.error_status_table);
1455 av_freep(&s->er.er_temp_buffer);
1456 av_freep(&s->mb_index2xy);
1457 av_freep(&s->lambda_table);
1458
1459 av_freep(&s->cplx_tab);
1460 av_freep(&s->bits_tab);
1461
1462 s->linesize = s->uvlinesize = 0;
1463 }
1464
ff_mpv_common_frame_size_change(MpegEncContext * s)1465 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1466 {
1467 int i, err = 0;
1468
1469 if (!s->context_initialized)
1470 return AVERROR(EINVAL);
1471
1472 if (s->slice_context_count > 1) {
1473 for (i = 0; i < s->slice_context_count; i++) {
1474 free_duplicate_context(s->thread_context[i]);
1475 }
1476 for (i = 1; i < s->slice_context_count; i++) {
1477 av_freep(&s->thread_context[i]);
1478 }
1479 } else
1480 free_duplicate_context(s);
1481
1482 free_context_frame(s);
1483
1484 if (s->picture)
1485 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1486 s->picture[i].needs_realloc = 1;
1487 }
1488
1489 s->last_picture_ptr =
1490 s->next_picture_ptr =
1491 s->current_picture_ptr = NULL;
1492
1493 // init
1494 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1495 s->mb_height = (s->height + 31) / 32 * 2;
1496 else
1497 s->mb_height = (s->height + 15) / 16;
1498
1499 if ((s->width || s->height) &&
1500 (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1501 goto fail;
1502
1503 if ((err = init_context_frame(s)))
1504 goto fail;
1505
1506 s->thread_context[0] = s;
1507
1508 if (s->width && s->height) {
1509 int nb_slices = s->slice_context_count;
1510 if (nb_slices > 1) {
1511 for (i = 1; i < nb_slices; i++) {
1512 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1513 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1514 }
1515
1516 for (i = 0; i < nb_slices; i++) {
1517 if ((err = init_duplicate_context(s->thread_context[i])) < 0)
1518 goto fail;
1519 s->thread_context[i]->start_mb_y =
1520 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1521 s->thread_context[i]->end_mb_y =
1522 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1523 }
1524 } else {
1525 err = init_duplicate_context(s);
1526 if (err < 0)
1527 goto fail;
1528 s->start_mb_y = 0;
1529 s->end_mb_y = s->mb_height;
1530 }
1531 s->slice_context_count = nb_slices;
1532 }
1533
1534 return 0;
1535 fail:
1536 ff_mpv_common_end(s);
1537 return err;
1538 }
1539
1540 /* init common structure for both encoder and decoder */
ff_mpv_common_end(MpegEncContext * s)1541 void ff_mpv_common_end(MpegEncContext *s)
1542 {
1543 int i;
1544
1545 if (s->slice_context_count > 1) {
1546 for (i = 0; i < s->slice_context_count; i++) {
1547 free_duplicate_context(s->thread_context[i]);
1548 }
1549 for (i = 1; i < s->slice_context_count; i++) {
1550 av_freep(&s->thread_context[i]);
1551 }
1552 s->slice_context_count = 1;
1553 } else free_duplicate_context(s);
1554
1555 av_freep(&s->parse_context.buffer);
1556 s->parse_context.buffer_size = 0;
1557
1558 av_freep(&s->bitstream_buffer);
1559 s->allocated_bitstream_buffer_size = 0;
1560
1561 if (s->picture) {
1562 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1563 ff_free_picture_tables(&s->picture[i]);
1564 ff_mpeg_unref_picture(s, &s->picture[i]);
1565 av_frame_free(&s->picture[i].f);
1566 }
1567 }
1568 av_freep(&s->picture);
1569 ff_free_picture_tables(&s->last_picture);
1570 ff_mpeg_unref_picture(s, &s->last_picture);
1571 av_frame_free(&s->last_picture.f);
1572 ff_free_picture_tables(&s->current_picture);
1573 ff_mpeg_unref_picture(s, &s->current_picture);
1574 av_frame_free(&s->current_picture.f);
1575 ff_free_picture_tables(&s->next_picture);
1576 ff_mpeg_unref_picture(s, &s->next_picture);
1577 av_frame_free(&s->next_picture.f);
1578 ff_free_picture_tables(&s->new_picture);
1579 ff_mpeg_unref_picture(s, &s->new_picture);
1580 av_frame_free(&s->new_picture.f);
1581
1582 free_context_frame(s);
1583
1584 s->context_initialized = 0;
1585 s->last_picture_ptr =
1586 s->next_picture_ptr =
1587 s->current_picture_ptr = NULL;
1588 s->linesize = s->uvlinesize = 0;
1589 }
1590
ff_init_rl(RLTable * rl,uint8_t static_store[2][2* MAX_RUN+MAX_LEVEL+3])1591 av_cold void ff_init_rl(RLTable *rl,
1592 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1593 {
1594 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1595 uint8_t index_run[MAX_RUN + 1];
1596 int last, run, level, start, end, i;
1597
1598 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1599 if (static_store && rl->max_level[0])
1600 return;
1601
1602 /* compute max_level[], max_run[] and index_run[] */
1603 for (last = 0; last < 2; last++) {
1604 if (last == 0) {
1605 start = 0;
1606 end = rl->last;
1607 } else {
1608 start = rl->last;
1609 end = rl->n;
1610 }
1611
1612 memset(max_level, 0, MAX_RUN + 1);
1613 memset(max_run, 0, MAX_LEVEL + 1);
1614 memset(index_run, rl->n, MAX_RUN + 1);
1615 for (i = start; i < end; i++) {
1616 run = rl->table_run[i];
1617 level = rl->table_level[i];
1618 if (index_run[run] == rl->n)
1619 index_run[run] = i;
1620 if (level > max_level[run])
1621 max_level[run] = level;
1622 if (run > max_run[level])
1623 max_run[level] = run;
1624 }
1625 if (static_store)
1626 rl->max_level[last] = static_store[last];
1627 else
1628 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1629 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1630 if (static_store)
1631 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1632 else
1633 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1634 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1635 if (static_store)
1636 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1637 else
1638 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1639 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1640 }
1641 }
1642
ff_init_vlc_rl(RLTable * rl,unsigned static_size)1643 av_cold void ff_init_vlc_rl(RLTable *rl, unsigned static_size)
1644 {
1645 int i, q;
1646 VLC_TYPE table[1500][2] = {{0}};
1647 VLC vlc = { .table = table, .table_allocated = static_size };
1648 av_assert0(static_size <= FF_ARRAY_ELEMS(table));
1649 init_vlc(&vlc, 9, rl->n + 1, &rl->table_vlc[0][1], 4, 2, &rl->table_vlc[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);
1650
1651 for (q = 0; q < 32; q++) {
1652 int qmul = q * 2;
1653 int qadd = (q - 1) | 1;
1654
1655 if (q == 0) {
1656 qmul = 1;
1657 qadd = 0;
1658 }
1659 for (i = 0; i < vlc.table_size; i++) {
1660 int code = vlc.table[i][0];
1661 int len = vlc.table[i][1];
1662 int level, run;
1663
1664 if (len == 0) { // illegal code
1665 run = 66;
1666 level = MAX_LEVEL;
1667 } else if (len < 0) { // more bits needed
1668 run = 0;
1669 level = code;
1670 } else {
1671 if (code == rl->n) { // esc
1672 run = 66;
1673 level = 0;
1674 } else {
1675 run = rl->table_run[code] + 1;
1676 level = rl->table_level[code] * qmul + qadd;
1677 if (code >= rl->last) run += 192;
1678 }
1679 }
1680 rl->rl_vlc[q][i].len = len;
1681 rl->rl_vlc[q][i].level = level;
1682 rl->rl_vlc[q][i].run = run;
1683 }
1684 }
1685 }
1686
release_unused_pictures(MpegEncContext * s)1687 static void release_unused_pictures(MpegEncContext *s)
1688 {
1689 int i;
1690
1691 /* release non reference frames */
1692 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1693 if (!s->picture[i].reference)
1694 ff_mpeg_unref_picture(s, &s->picture[i]);
1695 }
1696 }
1697
pic_is_unused(MpegEncContext * s,Picture * pic)1698 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1699 {
1700 if (pic == s->last_picture_ptr)
1701 return 0;
1702 if (!pic->f->buf[0])
1703 return 1;
1704 if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1705 return 1;
1706 return 0;
1707 }
1708
find_unused_picture(MpegEncContext * s,int shared)1709 static int find_unused_picture(MpegEncContext *s, int shared)
1710 {
1711 int i;
1712
1713 if (shared) {
1714 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1715 if (!s->picture[i].f->buf[0] && &s->picture[i] != s->last_picture_ptr)
1716 return i;
1717 }
1718 } else {
1719 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1720 if (pic_is_unused(s, &s->picture[i]))
1721 return i;
1722 }
1723 }
1724
1725 av_log(s->avctx, AV_LOG_FATAL,
1726 "Internal error, picture buffer overflow\n");
1727 /* We could return -1, but the codec would crash trying to draw into a
1728 * non-existing frame anyway. This is safer than waiting for a random crash.
1729 * Also the return of this is never useful, an encoder must only allocate
1730 * as much as allowed in the specification. This has no relationship to how
1731 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1732 * enough for such valid streams).
1733 * Plus, a decoder has to check stream validity and remove frames if too
1734 * many reference frames are around. Waiting for "OOM" is not correct at
1735 * all. Similarly, missing reference frames have to be replaced by
1736 * interpolated/MC frames, anything else is a bug in the codec ...
1737 */
1738 abort();
1739 return -1;
1740 }
1741
ff_find_unused_picture(MpegEncContext * s,int shared)1742 int ff_find_unused_picture(MpegEncContext *s, int shared)
1743 {
1744 int ret = find_unused_picture(s, shared);
1745
1746 if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1747 if (s->picture[ret].needs_realloc) {
1748 s->picture[ret].needs_realloc = 0;
1749 ff_free_picture_tables(&s->picture[ret]);
1750 ff_mpeg_unref_picture(s, &s->picture[ret]);
1751 }
1752 }
1753 return ret;
1754 }
1755
gray_frame(AVFrame * frame)1756 static void gray_frame(AVFrame *frame)
1757 {
1758 int i, h_chroma_shift, v_chroma_shift;
1759
1760 av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1761
1762 for(i=0; i<frame->height; i++)
1763 memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1764 for(i=0; i<FF_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1765 memset(frame->data[1] + frame->linesize[1]*i,
1766 0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1767 memset(frame->data[2] + frame->linesize[2]*i,
1768 0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1769 }
1770 }
1771
1772 /**
1773 * generic function called after decoding
1774 * the header and before a frame is decoded.
1775 */
ff_mpv_frame_start(MpegEncContext * s,AVCodecContext * avctx)1776 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1777 {
1778 int i, ret;
1779 Picture *pic;
1780 s->mb_skipped = 0;
1781
1782 if (!ff_thread_can_start_frame(avctx)) {
1783 av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1784 return -1;
1785 }
1786
1787 /* mark & release old frames */
1788 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1789 s->last_picture_ptr != s->next_picture_ptr &&
1790 s->last_picture_ptr->f->buf[0]) {
1791 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1792 }
1793
1794 /* release forgotten pictures */
1795 /* if (mpeg124/h263) */
1796 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1797 if (&s->picture[i] != s->last_picture_ptr &&
1798 &s->picture[i] != s->next_picture_ptr &&
1799 s->picture[i].reference && !s->picture[i].needs_realloc) {
1800 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1801 av_log(avctx, AV_LOG_ERROR,
1802 "releasing zombie picture\n");
1803 ff_mpeg_unref_picture(s, &s->picture[i]);
1804 }
1805 }
1806
1807 ff_mpeg_unref_picture(s, &s->current_picture);
1808
1809 release_unused_pictures(s);
1810
1811 if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1812 // we already have a unused image
1813 // (maybe it was set before reading the header)
1814 pic = s->current_picture_ptr;
1815 } else {
1816 i = ff_find_unused_picture(s, 0);
1817 if (i < 0) {
1818 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1819 return i;
1820 }
1821 pic = &s->picture[i];
1822 }
1823
1824 pic->reference = 0;
1825 if (!s->droppable) {
1826 if (s->pict_type != AV_PICTURE_TYPE_B)
1827 pic->reference = 3;
1828 }
1829
1830 pic->f->coded_picture_number = s->coded_picture_number++;
1831
1832 if (ff_alloc_picture(s, pic, 0) < 0)
1833 return -1;
1834
1835 s->current_picture_ptr = pic;
1836 // FIXME use only the vars from current_pic
1837 s->current_picture_ptr->f->top_field_first = s->top_field_first;
1838 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1839 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1840 if (s->picture_structure != PICT_FRAME)
1841 s->current_picture_ptr->f->top_field_first =
1842 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1843 }
1844 s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1845 !s->progressive_sequence;
1846 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1847
1848 s->current_picture_ptr->f->pict_type = s->pict_type;
1849 // if (s->flags && CODEC_FLAG_QSCALE)
1850 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1851 s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1852
1853 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1854 s->current_picture_ptr)) < 0)
1855 return ret;
1856
1857 if (s->pict_type != AV_PICTURE_TYPE_B) {
1858 s->last_picture_ptr = s->next_picture_ptr;
1859 if (!s->droppable)
1860 s->next_picture_ptr = s->current_picture_ptr;
1861 }
1862 av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1863 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1864 s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1865 s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1866 s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1867 s->pict_type, s->droppable);
1868
1869 if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1870 (s->pict_type != AV_PICTURE_TYPE_I ||
1871 s->picture_structure != PICT_FRAME)) {
1872 int h_chroma_shift, v_chroma_shift;
1873 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1874 &h_chroma_shift, &v_chroma_shift);
1875 if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1876 av_log(avctx, AV_LOG_DEBUG,
1877 "allocating dummy last picture for B frame\n");
1878 else if (s->pict_type != AV_PICTURE_TYPE_I)
1879 av_log(avctx, AV_LOG_ERROR,
1880 "warning: first frame is no keyframe\n");
1881 else if (s->picture_structure != PICT_FRAME)
1882 av_log(avctx, AV_LOG_DEBUG,
1883 "allocate dummy last picture for field based first keyframe\n");
1884
1885 /* Allocate a dummy frame */
1886 i = ff_find_unused_picture(s, 0);
1887 if (i < 0) {
1888 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1889 return i;
1890 }
1891 s->last_picture_ptr = &s->picture[i];
1892
1893 s->last_picture_ptr->reference = 3;
1894 s->last_picture_ptr->f->key_frame = 0;
1895 s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1896
1897 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1898 s->last_picture_ptr = NULL;
1899 return -1;
1900 }
1901
1902 if (!avctx->hwaccel && !(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)) {
1903 for(i=0; i<avctx->height; i++)
1904 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1905 0x80, avctx->width);
1906 for(i=0; i<FF_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1907 memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1908 0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1909 memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1910 0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1911 }
1912
1913 if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1914 for(i=0; i<avctx->height; i++)
1915 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1916 }
1917 }
1918
1919 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1920 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1921 }
1922 if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1923 s->pict_type == AV_PICTURE_TYPE_B) {
1924 /* Allocate a dummy frame */
1925 i = ff_find_unused_picture(s, 0);
1926 if (i < 0) {
1927 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1928 return i;
1929 }
1930 s->next_picture_ptr = &s->picture[i];
1931
1932 s->next_picture_ptr->reference = 3;
1933 s->next_picture_ptr->f->key_frame = 0;
1934 s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1935
1936 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1937 s->next_picture_ptr = NULL;
1938 return -1;
1939 }
1940 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1941 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1942 }
1943
1944 #if 0 // BUFREF-FIXME
1945 memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1946 memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1947 #endif
1948 if (s->last_picture_ptr) {
1949 ff_mpeg_unref_picture(s, &s->last_picture);
1950 if (s->last_picture_ptr->f->buf[0] &&
1951 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1952 s->last_picture_ptr)) < 0)
1953 return ret;
1954 }
1955 if (s->next_picture_ptr) {
1956 ff_mpeg_unref_picture(s, &s->next_picture);
1957 if (s->next_picture_ptr->f->buf[0] &&
1958 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1959 s->next_picture_ptr)) < 0)
1960 return ret;
1961 }
1962
1963 av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1964 s->last_picture_ptr->f->buf[0]));
1965
1966 if (s->picture_structure!= PICT_FRAME) {
1967 int i;
1968 for (i = 0; i < 4; i++) {
1969 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1970 s->current_picture.f->data[i] +=
1971 s->current_picture.f->linesize[i];
1972 }
1973 s->current_picture.f->linesize[i] *= 2;
1974 s->last_picture.f->linesize[i] *= 2;
1975 s->next_picture.f->linesize[i] *= 2;
1976 }
1977 }
1978
1979 s->err_recognition = avctx->err_recognition;
1980
1981 /* set dequantizer, we can't do it during init as
1982 * it might change for mpeg4 and we can't do it in the header
1983 * decode as init is not called for mpeg4 there yet */
1984 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1985 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1986 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1987 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1988 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1989 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1990 } else {
1991 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1992 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1993 }
1994
1995 if (s->avctx->debug & FF_DEBUG_NOMC) {
1996 gray_frame(s->current_picture_ptr->f);
1997 }
1998
1999 return 0;
2000 }
2001
2002 /* called after a frame has been decoded. */
ff_mpv_frame_end(MpegEncContext * s)2003 void ff_mpv_frame_end(MpegEncContext *s)
2004 {
2005 emms_c();
2006
2007 if (s->current_picture.reference)
2008 ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
2009 }
2010
2011
2012 #if FF_API_VISMV
clip_line(int * sx,int * sy,int * ex,int * ey,int maxx)2013 static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx)
2014 {
2015 if(*sx > *ex)
2016 return clip_line(ex, ey, sx, sy, maxx);
2017
2018 if (*sx < 0) {
2019 if (*ex < 0)
2020 return 1;
2021 *sy = *ey + (*sy - *ey) * (int64_t)*ex / (*ex - *sx);
2022 *sx = 0;
2023 }
2024
2025 if (*ex > maxx) {
2026 if (*sx > maxx)
2027 return 1;
2028 *ey = *sy + (*ey - *sy) * (int64_t)(maxx - *sx) / (*ex - *sx);
2029 *ex = maxx;
2030 }
2031 return 0;
2032 }
2033
2034
2035 /**
2036 * Draw a line from (ex, ey) -> (sx, sy).
2037 * @param w width of the image
2038 * @param h height of the image
2039 * @param stride stride/linesize of the image
2040 * @param color color of the arrow
2041 */
draw_line(uint8_t * buf,int sx,int sy,int ex,int ey,int w,int h,int stride,int color)2042 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
2043 int w, int h, int stride, int color)
2044 {
2045 int x, y, fr, f;
2046
2047 if (clip_line(&sx, &sy, &ex, &ey, w - 1))
2048 return;
2049 if (clip_line(&sy, &sx, &ey, &ex, h - 1))
2050 return;
2051
2052 sx = av_clip(sx, 0, w - 1);
2053 sy = av_clip(sy, 0, h - 1);
2054 ex = av_clip(ex, 0, w - 1);
2055 ey = av_clip(ey, 0, h - 1);
2056
2057 buf[sy * stride + sx] += color;
2058
2059 if (FFABS(ex - sx) > FFABS(ey - sy)) {
2060 if (sx > ex) {
2061 FFSWAP(int, sx, ex);
2062 FFSWAP(int, sy, ey);
2063 }
2064 buf += sx + sy * stride;
2065 ex -= sx;
2066 f = ((ey - sy) << 16) / ex;
2067 for (x = 0; x <= ex; x++) {
2068 y = (x * f) >> 16;
2069 fr = (x * f) & 0xFFFF;
2070 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
2071 if(fr) buf[(y + 1) * stride + x] += (color * fr ) >> 16;
2072 }
2073 } else {
2074 if (sy > ey) {
2075 FFSWAP(int, sx, ex);
2076 FFSWAP(int, sy, ey);
2077 }
2078 buf += sx + sy * stride;
2079 ey -= sy;
2080 if (ey)
2081 f = ((ex - sx) << 16) / ey;
2082 else
2083 f = 0;
2084 for(y= 0; y <= ey; y++){
2085 x = (y*f) >> 16;
2086 fr = (y*f) & 0xFFFF;
2087 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
2088 if(fr) buf[y * stride + x + 1] += (color * fr ) >> 16;
2089 }
2090 }
2091 }
2092
2093 /**
2094 * Draw an arrow from (ex, ey) -> (sx, sy).
2095 * @param w width of the image
2096 * @param h height of the image
2097 * @param stride stride/linesize of the image
2098 * @param color color of the arrow
2099 */
draw_arrow(uint8_t * buf,int sx,int sy,int ex,int ey,int w,int h,int stride,int color,int tail,int direction)2100 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
2101 int ey, int w, int h, int stride, int color, int tail, int direction)
2102 {
2103 int dx,dy;
2104
2105 if (direction) {
2106 FFSWAP(int, sx, ex);
2107 FFSWAP(int, sy, ey);
2108 }
2109
2110 sx = av_clip(sx, -100, w + 100);
2111 sy = av_clip(sy, -100, h + 100);
2112 ex = av_clip(ex, -100, w + 100);
2113 ey = av_clip(ey, -100, h + 100);
2114
2115 dx = ex - sx;
2116 dy = ey - sy;
2117
2118 if (dx * dx + dy * dy > 3 * 3) {
2119 int rx = dx + dy;
2120 int ry = -dx + dy;
2121 int length = ff_sqrt((rx * rx + ry * ry) << 8);
2122
2123 // FIXME subpixel accuracy
2124 rx = ROUNDED_DIV(rx * 3 << 4, length);
2125 ry = ROUNDED_DIV(ry * 3 << 4, length);
2126
2127 if (tail) {
2128 rx = -rx;
2129 ry = -ry;
2130 }
2131
2132 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
2133 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
2134 }
2135 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
2136 }
2137 #endif
2138
add_mb(AVMotionVector * mb,uint32_t mb_type,int dst_x,int dst_y,int src_x,int src_y,int direction)2139 static int add_mb(AVMotionVector *mb, uint32_t mb_type,
2140 int dst_x, int dst_y,
2141 int src_x, int src_y,
2142 int direction)
2143 {
2144 if (dst_x == src_x && dst_y == src_y)
2145 return 0;
2146 mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
2147 mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
2148 mb->src_x = src_x;
2149 mb->src_y = src_y;
2150 mb->dst_x = dst_x;
2151 mb->dst_y = dst_y;
2152 mb->source = direction ? 1 : -1;
2153 mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
2154 return 1;
2155 }
2156
2157 /**
2158 * Print debugging info for the given picture.
2159 */
ff_print_debug_info2(AVCodecContext * avctx,AVFrame * pict,uint8_t * mbskip_table,uint32_t * mbtype_table,int8_t * qscale_table,int16_t (* motion_val[2])[2],int * low_delay,int mb_width,int mb_height,int mb_stride,int quarter_sample)2160 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
2161 uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
2162 int *low_delay,
2163 int mb_width, int mb_height, int mb_stride, int quarter_sample)
2164 {
2165 if ((avctx->flags2 & CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
2166 const int shift = 1 + quarter_sample;
2167 const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2168 const int mv_stride = (mb_width << mv_sample_log2) +
2169 (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2170 int mb_x, mb_y, mbcount = 0;
2171
2172 /* size is width * height * 2 * 4 where 2 is for directions and 4 is
2173 * for the maximum number of MB (4 MB in case of IS_8x8) */
2174 AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
2175 if (!mvs)
2176 return;
2177
2178 for (mb_y = 0; mb_y < mb_height; mb_y++) {
2179 for (mb_x = 0; mb_x < mb_width; mb_x++) {
2180 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
2181 for (direction = 0; direction < 2; direction++) {
2182 if (!USES_LIST(mb_type, direction))
2183 continue;
2184 if (IS_8X8(mb_type)) {
2185 for (i = 0; i < 4; i++) {
2186 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2187 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2188 int xy = (mb_x * 2 + (i & 1) +
2189 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2190 int mx = (motion_val[direction][xy][0] >> shift) + sx;
2191 int my = (motion_val[direction][xy][1] >> shift) + sy;
2192 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2193 }
2194 } else if (IS_16X8(mb_type)) {
2195 for (i = 0; i < 2; i++) {
2196 int sx = mb_x * 16 + 8;
2197 int sy = mb_y * 16 + 4 + 8 * i;
2198 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2199 int mx = (motion_val[direction][xy][0] >> shift);
2200 int my = (motion_val[direction][xy][1] >> shift);
2201
2202 if (IS_INTERLACED(mb_type))
2203 my *= 2;
2204
2205 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2206 }
2207 } else if (IS_8X16(mb_type)) {
2208 for (i = 0; i < 2; i++) {
2209 int sx = mb_x * 16 + 4 + 8 * i;
2210 int sy = mb_y * 16 + 8;
2211 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2212 int mx = motion_val[direction][xy][0] >> shift;
2213 int my = motion_val[direction][xy][1] >> shift;
2214
2215 if (IS_INTERLACED(mb_type))
2216 my *= 2;
2217
2218 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2219 }
2220 } else {
2221 int sx = mb_x * 16 + 8;
2222 int sy = mb_y * 16 + 8;
2223 int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
2224 int mx = (motion_val[direction][xy][0]>>shift) + sx;
2225 int my = (motion_val[direction][xy][1]>>shift) + sy;
2226 mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2227 }
2228 }
2229 }
2230 }
2231
2232 if (mbcount) {
2233 AVFrameSideData *sd;
2234
2235 av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
2236 sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
2237 if (!sd)
2238 return;
2239 memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
2240 }
2241
2242 av_freep(&mvs);
2243 }
2244
2245 /* TODO: export all the following to make them accessible for users (and filters) */
2246 if (avctx->hwaccel || !mbtype_table
2247 || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
2248 return;
2249
2250
2251 if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
2252 int x,y;
2253
2254 av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
2255 av_get_picture_type_char(pict->pict_type));
2256 for (y = 0; y < mb_height; y++) {
2257 for (x = 0; x < mb_width; x++) {
2258 if (avctx->debug & FF_DEBUG_SKIP) {
2259 int count = mbskip_table[x + y * mb_stride];
2260 if (count > 9)
2261 count = 9;
2262 av_log(avctx, AV_LOG_DEBUG, "%1d", count);
2263 }
2264 if (avctx->debug & FF_DEBUG_QP) {
2265 av_log(avctx, AV_LOG_DEBUG, "%2d",
2266 qscale_table[x + y * mb_stride]);
2267 }
2268 if (avctx->debug & FF_DEBUG_MB_TYPE) {
2269 int mb_type = mbtype_table[x + y * mb_stride];
2270 // Type & MV direction
2271 if (IS_PCM(mb_type))
2272 av_log(avctx, AV_LOG_DEBUG, "P");
2273 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
2274 av_log(avctx, AV_LOG_DEBUG, "A");
2275 else if (IS_INTRA4x4(mb_type))
2276 av_log(avctx, AV_LOG_DEBUG, "i");
2277 else if (IS_INTRA16x16(mb_type))
2278 av_log(avctx, AV_LOG_DEBUG, "I");
2279 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
2280 av_log(avctx, AV_LOG_DEBUG, "d");
2281 else if (IS_DIRECT(mb_type))
2282 av_log(avctx, AV_LOG_DEBUG, "D");
2283 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
2284 av_log(avctx, AV_LOG_DEBUG, "g");
2285 else if (IS_GMC(mb_type))
2286 av_log(avctx, AV_LOG_DEBUG, "G");
2287 else if (IS_SKIP(mb_type))
2288 av_log(avctx, AV_LOG_DEBUG, "S");
2289 else if (!USES_LIST(mb_type, 1))
2290 av_log(avctx, AV_LOG_DEBUG, ">");
2291 else if (!USES_LIST(mb_type, 0))
2292 av_log(avctx, AV_LOG_DEBUG, "<");
2293 else {
2294 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2295 av_log(avctx, AV_LOG_DEBUG, "X");
2296 }
2297
2298 // segmentation
2299 if (IS_8X8(mb_type))
2300 av_log(avctx, AV_LOG_DEBUG, "+");
2301 else if (IS_16X8(mb_type))
2302 av_log(avctx, AV_LOG_DEBUG, "-");
2303 else if (IS_8X16(mb_type))
2304 av_log(avctx, AV_LOG_DEBUG, "|");
2305 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
2306 av_log(avctx, AV_LOG_DEBUG, " ");
2307 else
2308 av_log(avctx, AV_LOG_DEBUG, "?");
2309
2310
2311 if (IS_INTERLACED(mb_type))
2312 av_log(avctx, AV_LOG_DEBUG, "=");
2313 else
2314 av_log(avctx, AV_LOG_DEBUG, " ");
2315 }
2316 }
2317 av_log(avctx, AV_LOG_DEBUG, "\n");
2318 }
2319 }
2320
2321 if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
2322 (avctx->debug_mv)) {
2323 int mb_y;
2324 int i;
2325 int h_chroma_shift, v_chroma_shift, block_height;
2326 #if FF_API_VISMV
2327 const int shift = 1 + quarter_sample;
2328 uint8_t *ptr;
2329 const int width = avctx->width;
2330 const int height = avctx->height;
2331 #endif
2332 const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2333 const int mv_stride = (mb_width << mv_sample_log2) +
2334 (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2335
2336 *low_delay = 0; // needed to see the vectors without trashing the buffers
2337
2338 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2339
2340 av_frame_make_writable(pict);
2341
2342 pict->opaque = NULL;
2343 #if FF_API_VISMV
2344 ptr = pict->data[0];
2345 #endif
2346 block_height = 16 >> v_chroma_shift;
2347
2348 for (mb_y = 0; mb_y < mb_height; mb_y++) {
2349 int mb_x;
2350 for (mb_x = 0; mb_x < mb_width; mb_x++) {
2351 const int mb_index = mb_x + mb_y * mb_stride;
2352 #if FF_API_VISMV
2353 if ((avctx->debug_mv) && motion_val[0]) {
2354 int type;
2355 for (type = 0; type < 3; type++) {
2356 int direction = 0;
2357 switch (type) {
2358 case 0:
2359 if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
2360 (pict->pict_type!= AV_PICTURE_TYPE_P))
2361 continue;
2362 direction = 0;
2363 break;
2364 case 1:
2365 if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
2366 (pict->pict_type!= AV_PICTURE_TYPE_B))
2367 continue;
2368 direction = 0;
2369 break;
2370 case 2:
2371 if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
2372 (pict->pict_type!= AV_PICTURE_TYPE_B))
2373 continue;
2374 direction = 1;
2375 break;
2376 }
2377 if (!USES_LIST(mbtype_table[mb_index], direction))
2378 continue;
2379
2380 if (IS_8X8(mbtype_table[mb_index])) {
2381 int i;
2382 for (i = 0; i < 4; i++) {
2383 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2384 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2385 int xy = (mb_x * 2 + (i & 1) +
2386 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2387 int mx = (motion_val[direction][xy][0] >> shift) + sx;
2388 int my = (motion_val[direction][xy][1] >> shift) + sy;
2389 draw_arrow(ptr, sx, sy, mx, my, width,
2390 height, pict->linesize[0], 100, 0, direction);
2391 }
2392 } else if (IS_16X8(mbtype_table[mb_index])) {
2393 int i;
2394 for (i = 0; i < 2; i++) {
2395 int sx = mb_x * 16 + 8;
2396 int sy = mb_y * 16 + 4 + 8 * i;
2397 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2398 int mx = (motion_val[direction][xy][0] >> shift);
2399 int my = (motion_val[direction][xy][1] >> shift);
2400
2401 if (IS_INTERLACED(mbtype_table[mb_index]))
2402 my *= 2;
2403
2404 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2405 height, pict->linesize[0], 100, 0, direction);
2406 }
2407 } else if (IS_8X16(mbtype_table[mb_index])) {
2408 int i;
2409 for (i = 0; i < 2; i++) {
2410 int sx = mb_x * 16 + 4 + 8 * i;
2411 int sy = mb_y * 16 + 8;
2412 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2413 int mx = motion_val[direction][xy][0] >> shift;
2414 int my = motion_val[direction][xy][1] >> shift;
2415
2416 if (IS_INTERLACED(mbtype_table[mb_index]))
2417 my *= 2;
2418
2419 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2420 height, pict->linesize[0], 100, 0, direction);
2421 }
2422 } else {
2423 int sx= mb_x * 16 + 8;
2424 int sy= mb_y * 16 + 8;
2425 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2426 int mx= (motion_val[direction][xy][0]>>shift) + sx;
2427 int my= (motion_val[direction][xy][1]>>shift) + sy;
2428 draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100, 0, direction);
2429 }
2430 }
2431 }
2432 #endif
2433 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2434 uint64_t c = (qscale_table[mb_index] * 128 / 31) *
2435 ULLN(0x0101010101010101);
2436 int y;
2437 for (y = 0; y < block_height; y++) {
2438 *(uint64_t *)(pict->data[1] + 8 * mb_x +
2439 (block_height * mb_y + y) *
2440 pict->linesize[1]) = c;
2441 *(uint64_t *)(pict->data[2] + 8 * mb_x +
2442 (block_height * mb_y + y) *
2443 pict->linesize[2]) = c;
2444 }
2445 }
2446 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2447 motion_val[0]) {
2448 int mb_type = mbtype_table[mb_index];
2449 uint64_t u,v;
2450 int y;
2451 #define COLOR(theta, r) \
2452 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2453 v = (int)(128 + r * sin(theta * 3.141592 / 180));
2454
2455
2456 u = v = 128;
2457 if (IS_PCM(mb_type)) {
2458 COLOR(120, 48)
2459 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2460 IS_INTRA16x16(mb_type)) {
2461 COLOR(30, 48)
2462 } else if (IS_INTRA4x4(mb_type)) {
2463 COLOR(90, 48)
2464 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2465 // COLOR(120, 48)
2466 } else if (IS_DIRECT(mb_type)) {
2467 COLOR(150, 48)
2468 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2469 COLOR(170, 48)
2470 } else if (IS_GMC(mb_type)) {
2471 COLOR(190, 48)
2472 } else if (IS_SKIP(mb_type)) {
2473 // COLOR(180, 48)
2474 } else if (!USES_LIST(mb_type, 1)) {
2475 COLOR(240, 48)
2476 } else if (!USES_LIST(mb_type, 0)) {
2477 COLOR(0, 48)
2478 } else {
2479 av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2480 COLOR(300,48)
2481 }
2482
2483 u *= ULLN(0x0101010101010101);
2484 v *= ULLN(0x0101010101010101);
2485 for (y = 0; y < block_height; y++) {
2486 *(uint64_t *)(pict->data[1] + 8 * mb_x +
2487 (block_height * mb_y + y) * pict->linesize[1]) = u;
2488 *(uint64_t *)(pict->data[2] + 8 * mb_x +
2489 (block_height * mb_y + y) * pict->linesize[2]) = v;
2490 }
2491
2492 // segmentation
2493 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2494 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2495 (16 * mb_y + 8) * pict->linesize[0]) ^= ULLN(0x8080808080808080);
2496 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2497 (16 * mb_y + 8) * pict->linesize[0]) ^= ULLN(0x8080808080808080);
2498 }
2499 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2500 for (y = 0; y < 16; y++)
2501 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2502 pict->linesize[0]] ^= 0x80;
2503 }
2504 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2505 int dm = 1 << (mv_sample_log2 - 2);
2506 for (i = 0; i < 4; i++) {
2507 int sx = mb_x * 16 + 8 * (i & 1);
2508 int sy = mb_y * 16 + 8 * (i >> 1);
2509 int xy = (mb_x * 2 + (i & 1) +
2510 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2511 // FIXME bidir
2512 int32_t *mv = (int32_t *) &motion_val[0][xy];
2513 if (mv[0] != mv[dm] ||
2514 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2515 for (y = 0; y < 8; y++)
2516 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2517 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2518 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2519 pict->linesize[0]) ^= ULLN(0x8080808080808080);
2520 }
2521 }
2522
2523 if (IS_INTERLACED(mb_type) &&
2524 avctx->codec->id == AV_CODEC_ID_H264) {
2525 // hmm
2526 }
2527 }
2528 mbskip_table[mb_index] = 0;
2529 }
2530 }
2531 }
2532 }
2533
ff_print_debug_info(MpegEncContext * s,Picture * p,AVFrame * pict)2534 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
2535 {
2536 ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
2537 p->qscale_table, p->motion_val, &s->low_delay,
2538 s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2539 }
2540
ff_mpv_export_qp_table(MpegEncContext * s,AVFrame * f,Picture * p,int qp_type)2541 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
2542 {
2543 AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
2544 int offset = 2*s->mb_stride + 1;
2545 if(!ref)
2546 return AVERROR(ENOMEM);
2547 av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
2548 ref->size -= offset;
2549 ref->data += offset;
2550 return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
2551 }
2552
hpel_motion_lowres(MpegEncContext * s,uint8_t * dest,uint8_t * src,int field_based,int field_select,int src_x,int src_y,int width,int height,ptrdiff_t stride,int h_edge_pos,int v_edge_pos,int w,int h,h264_chroma_mc_func * pix_op,int motion_x,int motion_y)2553 static inline int hpel_motion_lowres(MpegEncContext *s,
2554 uint8_t *dest, uint8_t *src,
2555 int field_based, int field_select,
2556 int src_x, int src_y,
2557 int width, int height, ptrdiff_t stride,
2558 int h_edge_pos, int v_edge_pos,
2559 int w, int h, h264_chroma_mc_func *pix_op,
2560 int motion_x, int motion_y)
2561 {
2562 const int lowres = s->avctx->lowres;
2563 const int op_index = FFMIN(lowres, 3);
2564 const int s_mask = (2 << lowres) - 1;
2565 int emu = 0;
2566 int sx, sy;
2567
2568 if (s->quarter_sample) {
2569 motion_x /= 2;
2570 motion_y /= 2;
2571 }
2572
2573 sx = motion_x & s_mask;
2574 sy = motion_y & s_mask;
2575 src_x += motion_x >> lowres + 1;
2576 src_y += motion_y >> lowres + 1;
2577
2578 src += src_y * stride + src_x;
2579
2580 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
2581 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2582 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
2583 s->linesize, s->linesize,
2584 w + 1, (h + 1) << field_based,
2585 src_x, src_y << field_based,
2586 h_edge_pos, v_edge_pos);
2587 src = s->edge_emu_buffer;
2588 emu = 1;
2589 }
2590
2591 sx = (sx << 2) >> lowres;
2592 sy = (sy << 2) >> lowres;
2593 if (field_select)
2594 src += s->linesize;
2595 pix_op[op_index](dest, src, stride, h, sx, sy);
2596 return emu;
2597 }
2598
2599 /* apply one mpeg motion vector to the three components */
mpeg_motion_lowres(MpegEncContext * s,uint8_t * dest_y,uint8_t * dest_cb,uint8_t * dest_cr,int field_based,int bottom_field,int field_select,uint8_t ** ref_picture,h264_chroma_mc_func * pix_op,int motion_x,int motion_y,int h,int mb_y)2600 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2601 uint8_t *dest_y,
2602 uint8_t *dest_cb,
2603 uint8_t *dest_cr,
2604 int field_based,
2605 int bottom_field,
2606 int field_select,
2607 uint8_t **ref_picture,
2608 h264_chroma_mc_func *pix_op,
2609 int motion_x, int motion_y,
2610 int h, int mb_y)
2611 {
2612 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2613 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
2614 ptrdiff_t uvlinesize, linesize;
2615 const int lowres = s->avctx->lowres;
2616 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
2617 const int block_s = 8>>lowres;
2618 const int s_mask = (2 << lowres) - 1;
2619 const int h_edge_pos = s->h_edge_pos >> lowres;
2620 const int v_edge_pos = s->v_edge_pos >> lowres;
2621 linesize = s->current_picture.f->linesize[0] << field_based;
2622 uvlinesize = s->current_picture.f->linesize[1] << field_based;
2623
2624 // FIXME obviously not perfect but qpel will not work in lowres anyway
2625 if (s->quarter_sample) {
2626 motion_x /= 2;
2627 motion_y /= 2;
2628 }
2629
2630 if(field_based){
2631 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2632 }
2633
2634 sx = motion_x & s_mask;
2635 sy = motion_y & s_mask;
2636 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2637 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2638
2639 if (s->out_format == FMT_H263) {
2640 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
2641 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
2642 uvsrc_x = src_x >> 1;
2643 uvsrc_y = src_y >> 1;
2644 } else if (s->out_format == FMT_H261) {
2645 // even chroma mv's are full pel in H261
2646 mx = motion_x / 4;
2647 my = motion_y / 4;
2648 uvsx = (2 * mx) & s_mask;
2649 uvsy = (2 * my) & s_mask;
2650 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2651 uvsrc_y = mb_y * block_s + (my >> lowres);
2652 } else {
2653 if(s->chroma_y_shift){
2654 mx = motion_x / 2;
2655 my = motion_y / 2;
2656 uvsx = mx & s_mask;
2657 uvsy = my & s_mask;
2658 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
2659 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
2660 } else {
2661 if(s->chroma_x_shift){
2662 //Chroma422
2663 mx = motion_x / 2;
2664 uvsx = mx & s_mask;
2665 uvsy = motion_y & s_mask;
2666 uvsrc_y = src_y;
2667 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2668 } else {
2669 //Chroma444
2670 uvsx = motion_x & s_mask;
2671 uvsy = motion_y & s_mask;
2672 uvsrc_x = src_x;
2673 uvsrc_y = src_y;
2674 }
2675 }
2676 }
2677
2678 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2679 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2680 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2681
2682 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
2683 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2684 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2685 linesize >> field_based, linesize >> field_based,
2686 17, 17 + field_based,
2687 src_x, src_y << field_based, h_edge_pos,
2688 v_edge_pos);
2689 ptr_y = s->edge_emu_buffer;
2690 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2691 uint8_t *ubuf = s->edge_emu_buffer + 18 * s->linesize;
2692 uint8_t *vbuf =ubuf + 9 * s->uvlinesize;
2693 s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
2694 uvlinesize >> field_based, uvlinesize >> field_based,
2695 9, 9 + field_based,
2696 uvsrc_x, uvsrc_y << field_based,
2697 h_edge_pos >> 1, v_edge_pos >> 1);
2698 s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
2699 uvlinesize >> field_based,uvlinesize >> field_based,
2700 9, 9 + field_based,
2701 uvsrc_x, uvsrc_y << field_based,
2702 h_edge_pos >> 1, v_edge_pos >> 1);
2703 ptr_cb = ubuf;
2704 ptr_cr = vbuf;
2705 }
2706 }
2707
2708 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
2709 if (bottom_field) {
2710 dest_y += s->linesize;
2711 dest_cb += s->uvlinesize;
2712 dest_cr += s->uvlinesize;
2713 }
2714
2715 if (field_select) {
2716 ptr_y += s->linesize;
2717 ptr_cb += s->uvlinesize;
2718 ptr_cr += s->uvlinesize;
2719 }
2720
2721 sx = (sx << 2) >> lowres;
2722 sy = (sy << 2) >> lowres;
2723 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2724
2725 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2726 int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
2727 uvsx = (uvsx << 2) >> lowres;
2728 uvsy = (uvsy << 2) >> lowres;
2729 if (hc) {
2730 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2731 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2732 }
2733 }
2734 // FIXME h261 lowres loop filter
2735 }
2736
chroma_4mv_motion_lowres(MpegEncContext * s,uint8_t * dest_cb,uint8_t * dest_cr,uint8_t ** ref_picture,h264_chroma_mc_func * pix_op,int mx,int my)2737 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2738 uint8_t *dest_cb, uint8_t *dest_cr,
2739 uint8_t **ref_picture,
2740 h264_chroma_mc_func * pix_op,
2741 int mx, int my)
2742 {
2743 const int lowres = s->avctx->lowres;
2744 const int op_index = FFMIN(lowres, 3);
2745 const int block_s = 8 >> lowres;
2746 const int s_mask = (2 << lowres) - 1;
2747 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2748 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2749 int emu = 0, src_x, src_y, sx, sy;
2750 ptrdiff_t offset;
2751 uint8_t *ptr;
2752
2753 if (s->quarter_sample) {
2754 mx /= 2;
2755 my /= 2;
2756 }
2757
2758 /* In case of 8X8, we construct a single chroma motion vector
2759 with a special rounding */
2760 mx = ff_h263_round_chroma(mx);
2761 my = ff_h263_round_chroma(my);
2762
2763 sx = mx & s_mask;
2764 sy = my & s_mask;
2765 src_x = s->mb_x * block_s + (mx >> lowres + 1);
2766 src_y = s->mb_y * block_s + (my >> lowres + 1);
2767
2768 offset = src_y * s->uvlinesize + src_x;
2769 ptr = ref_picture[1] + offset;
2770 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2771 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2772 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2773 s->uvlinesize, s->uvlinesize,
2774 9, 9,
2775 src_x, src_y, h_edge_pos, v_edge_pos);
2776 ptr = s->edge_emu_buffer;
2777 emu = 1;
2778 }
2779 sx = (sx << 2) >> lowres;
2780 sy = (sy << 2) >> lowres;
2781 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2782
2783 ptr = ref_picture[2] + offset;
2784 if (emu) {
2785 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2786 s->uvlinesize, s->uvlinesize,
2787 9, 9,
2788 src_x, src_y, h_edge_pos, v_edge_pos);
2789 ptr = s->edge_emu_buffer;
2790 }
2791 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2792 }
2793
2794 /**
2795 * motion compensation of a single macroblock
2796 * @param s context
2797 * @param dest_y luma destination pointer
2798 * @param dest_cb chroma cb/u destination pointer
2799 * @param dest_cr chroma cr/v destination pointer
2800 * @param dir direction (0->forward, 1->backward)
2801 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2802 * @param pix_op halfpel motion compensation function (average or put normally)
2803 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2804 */
MPV_motion_lowres(MpegEncContext * s,uint8_t * dest_y,uint8_t * dest_cb,uint8_t * dest_cr,int dir,uint8_t ** ref_picture,h264_chroma_mc_func * pix_op)2805 static inline void MPV_motion_lowres(MpegEncContext *s,
2806 uint8_t *dest_y, uint8_t *dest_cb,
2807 uint8_t *dest_cr,
2808 int dir, uint8_t **ref_picture,
2809 h264_chroma_mc_func *pix_op)
2810 {
2811 int mx, my;
2812 int mb_x, mb_y, i;
2813 const int lowres = s->avctx->lowres;
2814 const int block_s = 8 >>lowres;
2815
2816 mb_x = s->mb_x;
2817 mb_y = s->mb_y;
2818
2819 switch (s->mv_type) {
2820 case MV_TYPE_16X16:
2821 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2822 0, 0, 0,
2823 ref_picture, pix_op,
2824 s->mv[dir][0][0], s->mv[dir][0][1],
2825 2 * block_s, mb_y);
2826 break;
2827 case MV_TYPE_8X8:
2828 mx = 0;
2829 my = 0;
2830 for (i = 0; i < 4; i++) {
2831 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2832 s->linesize) * block_s,
2833 ref_picture[0], 0, 0,
2834 (2 * mb_x + (i & 1)) * block_s,
2835 (2 * mb_y + (i >> 1)) * block_s,
2836 s->width, s->height, s->linesize,
2837 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2838 block_s, block_s, pix_op,
2839 s->mv[dir][i][0], s->mv[dir][i][1]);
2840
2841 mx += s->mv[dir][i][0];
2842 my += s->mv[dir][i][1];
2843 }
2844
2845 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2846 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2847 pix_op, mx, my);
2848 break;
2849 case MV_TYPE_FIELD:
2850 if (s->picture_structure == PICT_FRAME) {
2851 /* top field */
2852 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2853 1, 0, s->field_select[dir][0],
2854 ref_picture, pix_op,
2855 s->mv[dir][0][0], s->mv[dir][0][1],
2856 block_s, mb_y);
2857 /* bottom field */
2858 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2859 1, 1, s->field_select[dir][1],
2860 ref_picture, pix_op,
2861 s->mv[dir][1][0], s->mv[dir][1][1],
2862 block_s, mb_y);
2863 } else {
2864 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2865 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2866 ref_picture = s->current_picture_ptr->f->data;
2867
2868 }
2869 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2870 0, 0, s->field_select[dir][0],
2871 ref_picture, pix_op,
2872 s->mv[dir][0][0],
2873 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2874 }
2875 break;
2876 case MV_TYPE_16X8:
2877 for (i = 0; i < 2; i++) {
2878 uint8_t **ref2picture;
2879
2880 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2881 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2882 ref2picture = ref_picture;
2883 } else {
2884 ref2picture = s->current_picture_ptr->f->data;
2885 }
2886
2887 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2888 0, 0, s->field_select[dir][i],
2889 ref2picture, pix_op,
2890 s->mv[dir][i][0], s->mv[dir][i][1] +
2891 2 * block_s * i, block_s, mb_y >> 1);
2892
2893 dest_y += 2 * block_s * s->linesize;
2894 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2895 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2896 }
2897 break;
2898 case MV_TYPE_DMV:
2899 if (s->picture_structure == PICT_FRAME) {
2900 for (i = 0; i < 2; i++) {
2901 int j;
2902 for (j = 0; j < 2; j++) {
2903 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2904 1, j, j ^ i,
2905 ref_picture, pix_op,
2906 s->mv[dir][2 * i + j][0],
2907 s->mv[dir][2 * i + j][1],
2908 block_s, mb_y);
2909 }
2910 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2911 }
2912 } else {
2913 for (i = 0; i < 2; i++) {
2914 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2915 0, 0, s->picture_structure != i + 1,
2916 ref_picture, pix_op,
2917 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2918 2 * block_s, mb_y >> 1);
2919
2920 // after put we make avg of the same block
2921 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2922
2923 // opposite parity is always in the same
2924 // frame if this is second field
2925 if (!s->first_field) {
2926 ref_picture = s->current_picture_ptr->f->data;
2927 }
2928 }
2929 }
2930 break;
2931 default:
2932 av_assert2(0);
2933 }
2934 }
2935
2936 /**
2937 * find the lowest MB row referenced in the MVs
2938 */
ff_mpv_lowest_referenced_row(MpegEncContext * s,int dir)2939 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2940 {
2941 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2942 int my, off, i, mvs;
2943
2944 if (s->picture_structure != PICT_FRAME || s->mcsel)
2945 goto unhandled;
2946
2947 switch (s->mv_type) {
2948 case MV_TYPE_16X16:
2949 mvs = 1;
2950 break;
2951 case MV_TYPE_16X8:
2952 mvs = 2;
2953 break;
2954 case MV_TYPE_8X8:
2955 mvs = 4;
2956 break;
2957 default:
2958 goto unhandled;
2959 }
2960
2961 for (i = 0; i < mvs; i++) {
2962 my = s->mv[dir][i][1]<<qpel_shift;
2963 my_max = FFMAX(my_max, my);
2964 my_min = FFMIN(my_min, my);
2965 }
2966
2967 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2968
2969 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2970 unhandled:
2971 return s->mb_height-1;
2972 }
2973
2974 /* put block[] to dest[] */
put_dct(MpegEncContext * s,int16_t * block,int i,uint8_t * dest,int line_size,int qscale)2975 static inline void put_dct(MpegEncContext *s,
2976 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2977 {
2978 s->dct_unquantize_intra(s, block, i, qscale);
2979 s->idsp.idct_put(dest, line_size, block);
2980 }
2981
2982 /* add block[] to dest[] */
add_dct(MpegEncContext * s,int16_t * block,int i,uint8_t * dest,int line_size)2983 static inline void add_dct(MpegEncContext *s,
2984 int16_t *block, int i, uint8_t *dest, int line_size)
2985 {
2986 if (s->block_last_index[i] >= 0) {
2987 s->idsp.idct_add(dest, line_size, block);
2988 }
2989 }
2990
add_dequant_dct(MpegEncContext * s,int16_t * block,int i,uint8_t * dest,int line_size,int qscale)2991 static inline void add_dequant_dct(MpegEncContext *s,
2992 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2993 {
2994 if (s->block_last_index[i] >= 0) {
2995 s->dct_unquantize_inter(s, block, i, qscale);
2996
2997 s->idsp.idct_add(dest, line_size, block);
2998 }
2999 }
3000
3001 /**
3002 * Clean dc, ac, coded_block for the current non-intra MB.
3003 */
ff_clean_intra_table_entries(MpegEncContext * s)3004 void ff_clean_intra_table_entries(MpegEncContext *s)
3005 {
3006 int wrap = s->b8_stride;
3007 int xy = s->block_index[0];
3008
3009 s->dc_val[0][xy ] =
3010 s->dc_val[0][xy + 1 ] =
3011 s->dc_val[0][xy + wrap] =
3012 s->dc_val[0][xy + 1 + wrap] = 1024;
3013 /* ac pred */
3014 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3015 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3016 if (s->msmpeg4_version>=3) {
3017 s->coded_block[xy ] =
3018 s->coded_block[xy + 1 ] =
3019 s->coded_block[xy + wrap] =
3020 s->coded_block[xy + 1 + wrap] = 0;
3021 }
3022 /* chroma */
3023 wrap = s->mb_stride;
3024 xy = s->mb_x + s->mb_y * wrap;
3025 s->dc_val[1][xy] =
3026 s->dc_val[2][xy] = 1024;
3027 /* ac pred */
3028 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3029 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3030
3031 s->mbintra_table[xy]= 0;
3032 }
3033
3034 /* generic function called after a macroblock has been parsed by the
3035 decoder or after it has been encoded by the encoder.
3036
3037 Important variables used:
3038 s->mb_intra : true if intra macroblock
3039 s->mv_dir : motion vector direction
3040 s->mv_type : motion vector type
3041 s->mv : motion vector
3042 s->interlaced_dct : true if interlaced dct used (mpeg2)
3043 */
3044 static av_always_inline
mpv_decode_mb_internal(MpegEncContext * s,int16_t block[12][64],int lowres_flag,int is_mpeg12)3045 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
3046 int lowres_flag, int is_mpeg12)
3047 {
3048 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3049
3050 if (CONFIG_XVMC &&
3051 s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
3052 s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
3053 return;
3054 }
3055
3056 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3057 /* print DCT coefficients */
3058 int i,j;
3059 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
3060 for(i=0; i<6; i++){
3061 for(j=0; j<64; j++){
3062 av_log(s->avctx, AV_LOG_DEBUG, "%5d",
3063 block[i][s->idsp.idct_permutation[j]]);
3064 }
3065 av_log(s->avctx, AV_LOG_DEBUG, "\n");
3066 }
3067 }
3068
3069 s->current_picture.qscale_table[mb_xy] = s->qscale;
3070
3071 /* update DC predictors for P macroblocks */
3072 if (!s->mb_intra) {
3073 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
3074 if(s->mbintra_table[mb_xy])
3075 ff_clean_intra_table_entries(s);
3076 } else {
3077 s->last_dc[0] =
3078 s->last_dc[1] =
3079 s->last_dc[2] = 128 << s->intra_dc_precision;
3080 }
3081 }
3082 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
3083 s->mbintra_table[mb_xy]=1;
3084
3085 if ( (s->flags&CODEC_FLAG_PSNR)
3086 || s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor
3087 || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
3088 uint8_t *dest_y, *dest_cb, *dest_cr;
3089 int dct_linesize, dct_offset;
3090 op_pixels_func (*op_pix)[4];
3091 qpel_mc_func (*op_qpix)[16];
3092 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3093 const int uvlinesize = s->current_picture.f->linesize[1];
3094 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3095 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3096
3097 /* avoid copy if macroblock skipped in last frame too */
3098 /* skip only during decoding as we might trash the buffers during encoding a bit */
3099 if(!s->encoding){
3100 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3101
3102 if (s->mb_skipped) {
3103 s->mb_skipped= 0;
3104 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
3105 *mbskip_ptr = 1;
3106 } else if(!s->current_picture.reference) {
3107 *mbskip_ptr = 1;
3108 } else{
3109 *mbskip_ptr = 0; /* not skipped */
3110 }
3111 }
3112
3113 dct_linesize = linesize << s->interlaced_dct;
3114 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
3115
3116 if(readable){
3117 dest_y= s->dest[0];
3118 dest_cb= s->dest[1];
3119 dest_cr= s->dest[2];
3120 }else{
3121 dest_y = s->b_scratchpad;
3122 dest_cb= s->b_scratchpad+16*linesize;
3123 dest_cr= s->b_scratchpad+32*linesize;
3124 }
3125
3126 if (!s->mb_intra) {
3127 /* motion handling */
3128 /* decoding or more than one mb_type (MC was already done otherwise) */
3129 if(!s->encoding){
3130
3131 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
3132 if (s->mv_dir & MV_DIR_FORWARD) {
3133 ff_thread_await_progress(&s->last_picture_ptr->tf,
3134 ff_mpv_lowest_referenced_row(s, 0),
3135 0);
3136 }
3137 if (s->mv_dir & MV_DIR_BACKWARD) {
3138 ff_thread_await_progress(&s->next_picture_ptr->tf,
3139 ff_mpv_lowest_referenced_row(s, 1),
3140 0);
3141 }
3142 }
3143
3144 if(lowres_flag){
3145 h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
3146
3147 if (s->mv_dir & MV_DIR_FORWARD) {
3148 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
3149 op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
3150 }
3151 if (s->mv_dir & MV_DIR_BACKWARD) {
3152 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
3153 }
3154 }else{
3155 op_qpix = s->me.qpel_put;
3156 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
3157 op_pix = s->hdsp.put_pixels_tab;
3158 }else{
3159 op_pix = s->hdsp.put_no_rnd_pixels_tab;
3160 }
3161 if (s->mv_dir & MV_DIR_FORWARD) {
3162 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
3163 op_pix = s->hdsp.avg_pixels_tab;
3164 op_qpix= s->me.qpel_avg;
3165 }
3166 if (s->mv_dir & MV_DIR_BACKWARD) {
3167 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
3168 }
3169 }
3170 }
3171
3172 /* skip dequant / idct if we are really late ;) */
3173 if(s->avctx->skip_idct){
3174 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
3175 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
3176 || s->avctx->skip_idct >= AVDISCARD_ALL)
3177 goto skip_idct;
3178 }
3179
3180 /* add dct residue */
3181 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
3182 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
3183 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3184 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3185 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3186 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3187
3188 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3189 if (s->chroma_y_shift){
3190 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3191 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3192 }else{
3193 dct_linesize >>= 1;
3194 dct_offset >>=1;
3195 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3196 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3197 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3198 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3199 }
3200 }
3201 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
3202 add_dct(s, block[0], 0, dest_y , dct_linesize);
3203 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3204 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3205 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3206
3207 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3208 if(s->chroma_y_shift){//Chroma420
3209 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3210 add_dct(s, block[5], 5, dest_cr, uvlinesize);
3211 }else{
3212 //chroma422
3213 dct_linesize = uvlinesize << s->interlaced_dct;
3214 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3215
3216 add_dct(s, block[4], 4, dest_cb, dct_linesize);
3217 add_dct(s, block[5], 5, dest_cr, dct_linesize);
3218 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3219 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3220 if(!s->chroma_x_shift){//Chroma444
3221 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
3222 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
3223 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
3224 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
3225 }
3226 }
3227 }//fi gray
3228 }
3229 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
3230 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3231 }
3232 } else {
3233 /* dct only in intra block */
3234 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
3235 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3236 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3237 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3238 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3239
3240 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3241 if(s->chroma_y_shift){
3242 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3243 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3244 }else{
3245 dct_offset >>=1;
3246 dct_linesize >>=1;
3247 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3248 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3249 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3250 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3251 }
3252 }
3253 }else{
3254 s->idsp.idct_put(dest_y, dct_linesize, block[0]);
3255 s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
3256 s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
3257 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3258
3259 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3260 if(s->chroma_y_shift){
3261 s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
3262 s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
3263 }else{
3264
3265 dct_linesize = uvlinesize << s->interlaced_dct;
3266 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3267
3268 s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
3269 s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
3270 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3271 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3272 if(!s->chroma_x_shift){//Chroma444
3273 s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
3274 s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
3275 s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
3276 s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
3277 }
3278 }
3279 }//gray
3280 }
3281 }
3282 skip_idct:
3283 if(!readable){
3284 s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
3285 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3286 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3287 }
3288 }
3289 }
3290
ff_mpv_decode_mb(MpegEncContext * s,int16_t block[12][64])3291 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
3292 {
3293 #if !CONFIG_SMALL
3294 if(s->out_format == FMT_MPEG1) {
3295 if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
3296 else mpv_decode_mb_internal(s, block, 0, 1);
3297 } else
3298 #endif
3299 if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
3300 else mpv_decode_mb_internal(s, block, 0, 0);
3301 }
3302
ff_mpeg_draw_horiz_band(MpegEncContext * s,int y,int h)3303 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
3304 {
3305 ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
3306 s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
3307 s->first_field, s->low_delay);
3308 }
3309
ff_init_block_index(MpegEncContext * s)3310 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3311 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3312 const int uvlinesize = s->current_picture.f->linesize[1];
3313 const int mb_size= 4 - s->avctx->lowres;
3314
3315 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
3316 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
3317 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3318 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3319 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3320 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;
3321 //block_index is not used by mpeg2, so it is not affected by chroma_format
3322
3323 s->dest[0] = s->current_picture.f->data[0] + ((s->mb_x - 1) << mb_size);
3324 s->dest[1] = s->current_picture.f->data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3325 s->dest[2] = s->current_picture.f->data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3326
3327 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3328 {
3329 if(s->picture_structure==PICT_FRAME){
3330 s->dest[0] += s->mb_y * linesize << mb_size;
3331 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3332 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3333 }else{
3334 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
3335 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3336 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3337 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3338 }
3339 }
3340 }
3341
3342 /**
3343 * Permute an 8x8 block.
3344 * @param block the block which will be permuted according to the given permutation vector
3345 * @param permutation the permutation vector
3346 * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3347 * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3348 * (inverse) permutated to scantable order!
3349 */
ff_block_permute(int16_t * block,uint8_t * permutation,const uint8_t * scantable,int last)3350 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3351 {
3352 int i;
3353 int16_t temp[64];
3354
3355 if(last<=0) return;
3356 //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3357
3358 for(i=0; i<=last; i++){
3359 const int j= scantable[i];
3360 temp[j]= block[j];
3361 block[j]=0;
3362 }
3363
3364 for(i=0; i<=last; i++){
3365 const int j= scantable[i];
3366 const int perm_j= permutation[j];
3367 block[perm_j]= temp[j];
3368 }
3369 }
3370
ff_mpeg_flush(AVCodecContext * avctx)3371 void ff_mpeg_flush(AVCodecContext *avctx){
3372 int i;
3373 MpegEncContext *s = avctx->priv_data;
3374
3375 if (!s || !s->picture)
3376 return;
3377
3378 for (i = 0; i < MAX_PICTURE_COUNT; i++)
3379 ff_mpeg_unref_picture(s, &s->picture[i]);
3380 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3381
3382 ff_mpeg_unref_picture(s, &s->current_picture);
3383 ff_mpeg_unref_picture(s, &s->last_picture);
3384 ff_mpeg_unref_picture(s, &s->next_picture);
3385
3386 s->mb_x= s->mb_y= 0;
3387 s->closed_gop= 0;
3388
3389 s->parse_context.state= -1;
3390 s->parse_context.frame_start_found= 0;
3391 s->parse_context.overread= 0;
3392 s->parse_context.overread_index= 0;
3393 s->parse_context.index= 0;
3394 s->parse_context.last_index= 0;
3395 s->bitstream_buffer_size=0;
3396 s->pp_time=0;
3397 }
3398
3399 /**
3400 * set qscale and update qscale dependent variables.
3401 */
ff_set_qscale(MpegEncContext * s,int qscale)3402 void ff_set_qscale(MpegEncContext * s, int qscale)
3403 {
3404 if (qscale < 1)
3405 qscale = 1;
3406 else if (qscale > 31)
3407 qscale = 31;
3408
3409 s->qscale = qscale;
3410 s->chroma_qscale= s->chroma_qscale_table[qscale];
3411
3412 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3413 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3414 }
3415
ff_mpv_report_decode_progress(MpegEncContext * s)3416 void ff_mpv_report_decode_progress(MpegEncContext *s)
3417 {
3418 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3419 ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
3420 }
3421