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