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