f34c81dd0f7efab66c9d1a84e47fb58e2b7bed6a
[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 static int 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 = 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 void ff_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 ff_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 ff_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 ff_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 = 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
687 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
688 ff_mpeg_unref_picture(s, &s->picture[i]);
689 if (s1->picture[i].f.buf[0] &&
690 (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
691 return ret;
692 }
693
694 #define UPDATE_PICTURE(pic)\
695 do {\
696 ff_mpeg_unref_picture(s, &s->pic);\
697 if (s1->pic.f.buf[0])\
698 ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
699 else\
700 ret = update_picture_tables(&s->pic, &s1->pic);\
701 if (ret < 0)\
702 return ret;\
703 } while (0)
704
705 UPDATE_PICTURE(current_picture);
706 UPDATE_PICTURE(last_picture);
707 UPDATE_PICTURE(next_picture);
708
709 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
710 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
711 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
712
713 // Error/bug resilience
714 s->next_p_frame_damaged = s1->next_p_frame_damaged;
715 s->workaround_bugs = s1->workaround_bugs;
716
717 // MPEG4 timing info
718 memcpy(&s->last_time_base, &s1->last_time_base,
719 (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
720 (char *) &s1->last_time_base);
721
722 // B-frame info
723 s->max_b_frames = s1->max_b_frames;
724 s->low_delay = s1->low_delay;
725 s->droppable = s1->droppable;
726
727 // DivX handling (doesn't work)
728 s->divx_packed = s1->divx_packed;
729
730 if (s1->bitstream_buffer) {
731 if (s1->bitstream_buffer_size +
732 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
733 av_fast_malloc(&s->bitstream_buffer,
734 &s->allocated_bitstream_buffer_size,
735 s1->allocated_bitstream_buffer_size);
736 s->bitstream_buffer_size = s1->bitstream_buffer_size;
737 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
738 s1->bitstream_buffer_size);
739 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
740 FF_INPUT_BUFFER_PADDING_SIZE);
741 }
742
743 // linesize dependend scratch buffer allocation
744 if (!s->edge_emu_buffer)
745 if (s1->linesize) {
746 if (frame_size_alloc(s, s1->linesize) < 0) {
747 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
748 "scratch buffers.\n");
749 return AVERROR(ENOMEM);
750 }
751 } else {
752 av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
753 "be allocated due to unknown size.\n");
754 return AVERROR_BUG;
755 }
756
757 // MPEG2/interlacing info
758 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
759 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
760
761 if (!s1->first_field) {
762 s->last_pict_type = s1->pict_type;
763 if (s1->current_picture_ptr)
764 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
765 }
766
767 return 0;
768 }
769
770 /**
771 * Set the given MpegEncContext to common defaults
772 * (same for encoding and decoding).
773 * The changed fields will not depend upon the
774 * prior state of the MpegEncContext.
775 */
776 void ff_MPV_common_defaults(MpegEncContext *s)
777 {
778 s->y_dc_scale_table =
779 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
780 s->chroma_qscale_table = ff_default_chroma_qscale_table;
781 s->progressive_frame = 1;
782 s->progressive_sequence = 1;
783 s->picture_structure = PICT_FRAME;
784
785 s->coded_picture_number = 0;
786 s->picture_number = 0;
787
788 s->f_code = 1;
789 s->b_code = 1;
790
791 s->slice_context_count = 1;
792 }
793
794 /**
795 * Set the given MpegEncContext to defaults for decoding.
796 * the changed fields will not depend upon
797 * the prior state of the MpegEncContext.
798 */
799 void ff_MPV_decode_defaults(MpegEncContext *s)
800 {
801 ff_MPV_common_defaults(s);
802 }
803
804 static int init_er(MpegEncContext *s)
805 {
806 ERContext *er = &s->er;
807 int mb_array_size = s->mb_height * s->mb_stride;
808 int i;
809
810 er->avctx = s->avctx;
811 er->dsp = &s->dsp;
812
813 er->mb_index2xy = s->mb_index2xy;
814 er->mb_num = s->mb_num;
815 er->mb_width = s->mb_width;
816 er->mb_height = s->mb_height;
817 er->mb_stride = s->mb_stride;
818 er->b8_stride = s->b8_stride;
819
820 er->er_temp_buffer = av_malloc(s->mb_height * s->mb_stride);
821 er->error_status_table = av_mallocz(mb_array_size);
822 if (!er->er_temp_buffer || !er->error_status_table)
823 goto fail;
824
825 er->mbskip_table = s->mbskip_table;
826 er->mbintra_table = s->mbintra_table;
827
828 for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
829 er->dc_val[i] = s->dc_val[i];
830
831 er->decode_mb = mpeg_er_decode_mb;
832 er->opaque = s;
833
834 return 0;
835 fail:
836 av_freep(&er->er_temp_buffer);
837 av_freep(&er->error_status_table);
838 return AVERROR(ENOMEM);
839 }
840
841 /**
842 * Initialize and allocates MpegEncContext fields dependent on the resolution.
843 */
844 static int init_context_frame(MpegEncContext *s)
845 {
846 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
847
848 s->mb_width = (s->width + 15) / 16;
849 s->mb_stride = s->mb_width + 1;
850 s->b8_stride = s->mb_width * 2 + 1;
851 s->b4_stride = s->mb_width * 4 + 1;
852 mb_array_size = s->mb_height * s->mb_stride;
853 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
854
855 /* set default edge pos, will be overriden
856 * in decode_header if needed */
857 s->h_edge_pos = s->mb_width * 16;
858 s->v_edge_pos = s->mb_height * 16;
859
860 s->mb_num = s->mb_width * s->mb_height;
861
862 s->block_wrap[0] =
863 s->block_wrap[1] =
864 s->block_wrap[2] =
865 s->block_wrap[3] = s->b8_stride;
866 s->block_wrap[4] =
867 s->block_wrap[5] = s->mb_stride;
868
869 y_size = s->b8_stride * (2 * s->mb_height + 1);
870 c_size = s->mb_stride * (s->mb_height + 1);
871 yc_size = y_size + 2 * c_size;
872
873 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
874 fail); // error ressilience code looks cleaner with this
875 for (y = 0; y < s->mb_height; y++)
876 for (x = 0; x < s->mb_width; x++)
877 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
878
879 s->mb_index2xy[s->mb_height * s->mb_width] =
880 (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
881
882 if (s->encoding) {
883 /* Allocate MV tables */
884 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
885 mv_table_size * 2 * sizeof(int16_t), fail);
886 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
887 mv_table_size * 2 * sizeof(int16_t), fail);
888 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
889 mv_table_size * 2 * sizeof(int16_t), fail);
890 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
891 mv_table_size * 2 * sizeof(int16_t), fail);
892 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
893 mv_table_size * 2 * sizeof(int16_t), fail);
894 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
895 mv_table_size * 2 * sizeof(int16_t), fail);
896 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
897 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
898 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
899 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
900 s->mb_stride + 1;
901 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
902 s->mb_stride + 1;
903 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
904
905 /* Allocate MB type table */
906 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
907 sizeof(uint16_t), fail); // needed for encoding
908
909 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
910 sizeof(int), fail);
911
912 FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
913 mb_array_size * sizeof(float), fail);
914 FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
915 mb_array_size * sizeof(float), fail);
916
917 }
918
919 if (s->codec_id == AV_CODEC_ID_MPEG4 ||
920 (s->flags & CODEC_FLAG_INTERLACED_ME)) {
921 /* interlaced direct mode decoding tables */
922 for (i = 0; i < 2; i++) {
923 int j, k;
924 for (j = 0; j < 2; j++) {
925 for (k = 0; k < 2; k++) {
926 FF_ALLOCZ_OR_GOTO(s->avctx,
927 s->b_field_mv_table_base[i][j][k],
928 mv_table_size * 2 * sizeof(int16_t),
929 fail);
930 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
931 s->mb_stride + 1;
932 }
933 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
934 mb_array_size * 2 * sizeof(uint8_t), fail);
935 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
936 mv_table_size * 2 * sizeof(int16_t), fail);
937 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
938 + s->mb_stride + 1;
939 }
940 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
941 mb_array_size * 2 * sizeof(uint8_t), fail);
942 }
943 }
944 if (s->out_format == FMT_H263) {
945 /* cbp values */
946 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
947 s->coded_block = s->coded_block_base + s->b8_stride + 1;
948
949 /* cbp, ac_pred, pred_dir */
950 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
951 mb_array_size * sizeof(uint8_t), fail);
952 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
953 mb_array_size * sizeof(uint8_t), fail);
954 }
955
956 if (s->h263_pred || s->h263_plus || !s->encoding) {
957 /* dc values */
958 // MN: we need these for error resilience of intra-frames
959 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
960 yc_size * sizeof(int16_t), fail);
961 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
962 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
963 s->dc_val[2] = s->dc_val[1] + c_size;
964 for (i = 0; i < yc_size; i++)
965 s->dc_val_base[i] = 1024;
966 }
967
968 /* which mb is a intra block */
969 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
970 memset(s->mbintra_table, 1, mb_array_size);
971
972 /* init macroblock skip table */
973 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
974 // Note the + 1 is for a quicker mpeg4 slice_end detection
975
976 return init_er(s);
977 fail:
978 return AVERROR(ENOMEM);
979 }
980
981 /**
982 * init common structure for both encoder and decoder.
983 * this assumes that some variables like width/height are already set
984 */
985 av_cold int ff_MPV_common_init(MpegEncContext *s)
986 {
987 int i;
988 int nb_slices = (HAVE_THREADS &&
989 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
990 s->avctx->thread_count : 1;
991
992 if (s->encoding && s->avctx->slices)
993 nb_slices = s->avctx->slices;
994
995 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
996 s->mb_height = (s->height + 31) / 32 * 2;
997 else
998 s->mb_height = (s->height + 15) / 16;
999
1000 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1001 av_log(s->avctx, AV_LOG_ERROR,
1002 "decoding to AV_PIX_FMT_NONE is not supported.\n");
1003 return -1;
1004 }
1005
1006 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1007 int max_slices;
1008 if (s->mb_height)
1009 max_slices = FFMIN(MAX_THREADS, s->mb_height);
1010 else
1011 max_slices = MAX_THREADS;
1012 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1013 " reducing to %d\n", nb_slices, max_slices);
1014 nb_slices = max_slices;
1015 }
1016
1017 if ((s->width || s->height) &&
1018 av_image_check_size(s->width, s->height, 0, s->avctx))
1019 return -1;
1020
1021 ff_dct_common_init(s);
1022
1023 s->flags = s->avctx->flags;
1024 s->flags2 = s->avctx->flags2;
1025
1026 /* set chroma shifts */
1027 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1028 &s->chroma_x_shift,
1029 &s->chroma_y_shift);
1030
1031 /* convert fourcc to upper case */
1032 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
1033
1034 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
1035
1036 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1037 MAX_PICTURE_COUNT * sizeof(Picture), fail);
1038 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1039 av_frame_unref(&s->picture[i].f);
1040 }
1041 memset(&s->next_picture, 0, sizeof(s->next_picture));
1042 memset(&s->last_picture, 0, sizeof(s->last_picture));
1043 memset(&s->current_picture, 0, sizeof(s->current_picture));
1044 av_frame_unref(&s->next_picture.f);
1045 av_frame_unref(&s->last_picture.f);
1046 av_frame_unref(&s->current_picture.f);
1047
1048 if (s->width && s->height) {
1049 if (init_context_frame(s))
1050 goto fail;
1051
1052 s->parse_context.state = -1;
1053 }
1054
1055 s->context_initialized = 1;
1056 s->thread_context[0] = s;
1057
1058 if (s->width && s->height) {
1059 if (nb_slices > 1) {
1060 for (i = 1; i < nb_slices; i++) {
1061 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1062 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1063 }
1064
1065 for (i = 0; i < nb_slices; i++) {
1066 if (init_duplicate_context(s->thread_context[i]) < 0)
1067 goto fail;
1068 s->thread_context[i]->start_mb_y =
1069 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1070 s->thread_context[i]->end_mb_y =
1071 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1072 }
1073 } else {
1074 if (init_duplicate_context(s) < 0)
1075 goto fail;
1076 s->start_mb_y = 0;
1077 s->end_mb_y = s->mb_height;
1078 }
1079 s->slice_context_count = nb_slices;
1080 }
1081
1082 return 0;
1083 fail:
1084 ff_MPV_common_end(s);
1085 return -1;
1086 }
1087
1088 /**
1089 * Frees and resets MpegEncContext fields depending on the resolution.
1090 * Is used during resolution changes to avoid a full reinitialization of the
1091 * codec.
1092 */
1093 static int free_context_frame(MpegEncContext *s)
1094 {
1095 int i, j, k;
1096
1097 av_freep(&s->mb_type);
1098 av_freep(&s->p_mv_table_base);
1099 av_freep(&s->b_forw_mv_table_base);
1100 av_freep(&s->b_back_mv_table_base);
1101 av_freep(&s->b_bidir_forw_mv_table_base);
1102 av_freep(&s->b_bidir_back_mv_table_base);
1103 av_freep(&s->b_direct_mv_table_base);
1104 s->p_mv_table = NULL;
1105 s->b_forw_mv_table = NULL;
1106 s->b_back_mv_table = NULL;
1107 s->b_bidir_forw_mv_table = NULL;
1108 s->b_bidir_back_mv_table = NULL;
1109 s->b_direct_mv_table = NULL;
1110 for (i = 0; i < 2; i++) {
1111 for (j = 0; j < 2; j++) {
1112 for (k = 0; k < 2; k++) {
1113 av_freep(&s->b_field_mv_table_base[i][j][k]);
1114 s->b_field_mv_table[i][j][k] = NULL;
1115 }
1116 av_freep(&s->b_field_select_table[i][j]);
1117 av_freep(&s->p_field_mv_table_base[i][j]);
1118 s->p_field_mv_table[i][j] = NULL;
1119 }
1120 av_freep(&s->p_field_select_table[i]);
1121 }
1122
1123 av_freep(&s->dc_val_base);
1124 av_freep(&s->coded_block_base);
1125 av_freep(&s->mbintra_table);
1126 av_freep(&s->cbp_table);
1127 av_freep(&s->pred_dir_table);
1128
1129 av_freep(&s->mbskip_table);
1130
1131 av_freep(&s->er.error_status_table);
1132 av_freep(&s->er.er_temp_buffer);
1133 av_freep(&s->mb_index2xy);
1134 av_freep(&s->lambda_table);
1135 av_freep(&s->cplx_tab);
1136 av_freep(&s->bits_tab);
1137
1138 s->linesize = s->uvlinesize = 0;
1139
1140 return 0;
1141 }
1142
1143 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1144 {
1145 int i, err = 0;
1146
1147 if (s->slice_context_count > 1) {
1148 for (i = 0; i < s->slice_context_count; i++) {
1149 free_duplicate_context(s->thread_context[i]);
1150 }
1151 for (i = 1; i < s->slice_context_count; i++) {
1152 av_freep(&s->thread_context[i]);
1153 }
1154 } else
1155 free_duplicate_context(s);
1156
1157 if ((err = free_context_frame(s)) < 0)
1158 return err;
1159
1160 if (s->picture)
1161 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1162 s->picture[i].needs_realloc = 1;
1163 }
1164
1165 s->last_picture_ptr =
1166 s->next_picture_ptr =
1167 s->current_picture_ptr = NULL;
1168
1169 // init
1170 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1171 s->mb_height = (s->height + 31) / 32 * 2;
1172 else
1173 s->mb_height = (s->height + 15) / 16;
1174
1175 if ((s->width || s->height) &&
1176 av_image_check_size(s->width, s->height, 0, s->avctx))
1177 return AVERROR_INVALIDDATA;
1178
1179 if ((err = init_context_frame(s)))
1180 goto fail;
1181
1182 s->thread_context[0] = s;
1183
1184 if (s->width && s->height) {
1185 int nb_slices = s->slice_context_count;
1186 if (nb_slices > 1) {
1187 for (i = 1; i < nb_slices; i++) {
1188 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1189 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1190 }
1191
1192 for (i = 0; i < nb_slices; i++) {
1193 if (init_duplicate_context(s->thread_context[i]) < 0)
1194 goto fail;
1195 s->thread_context[i]->start_mb_y =
1196 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1197 s->thread_context[i]->end_mb_y =
1198 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1199 }
1200 } else {
1201 if (init_duplicate_context(s) < 0)
1202 goto fail;
1203 s->start_mb_y = 0;
1204 s->end_mb_y = s->mb_height;
1205 }
1206 s->slice_context_count = nb_slices;
1207 }
1208
1209 return 0;
1210 fail:
1211 ff_MPV_common_end(s);
1212 return err;
1213 }
1214
1215 /* init common structure for both encoder and decoder */
1216 void ff_MPV_common_end(MpegEncContext *s)
1217 {
1218 int i;
1219
1220 if (s->slice_context_count > 1) {
1221 for (i = 0; i < s->slice_context_count; i++) {
1222 free_duplicate_context(s->thread_context[i]);
1223 }
1224 for (i = 1; i < s->slice_context_count; i++) {
1225 av_freep(&s->thread_context[i]);
1226 }
1227 s->slice_context_count = 1;
1228 } else free_duplicate_context(s);
1229
1230 av_freep(&s->parse_context.buffer);
1231 s->parse_context.buffer_size = 0;
1232
1233 av_freep(&s->bitstream_buffer);
1234 s->allocated_bitstream_buffer_size = 0;
1235
1236 if (s->picture) {
1237 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1238 ff_free_picture_tables(&s->picture[i]);
1239 ff_mpeg_unref_picture(s, &s->picture[i]);
1240 }
1241 }
1242 av_freep(&s->picture);
1243 ff_free_picture_tables(&s->last_picture);
1244 ff_mpeg_unref_picture(s, &s->last_picture);
1245 ff_free_picture_tables(&s->current_picture);
1246 ff_mpeg_unref_picture(s, &s->current_picture);
1247 ff_free_picture_tables(&s->next_picture);
1248 ff_mpeg_unref_picture(s, &s->next_picture);
1249
1250 free_context_frame(s);
1251
1252 s->context_initialized = 0;
1253 s->last_picture_ptr =
1254 s->next_picture_ptr =
1255 s->current_picture_ptr = NULL;
1256 s->linesize = s->uvlinesize = 0;
1257 }
1258
1259 av_cold void ff_init_rl(RLTable *rl,
1260 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1261 {
1262 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1263 uint8_t index_run[MAX_RUN + 1];
1264 int last, run, level, start, end, i;
1265
1266 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1267 if (static_store && rl->max_level[0])
1268 return;
1269
1270 /* compute max_level[], max_run[] and index_run[] */
1271 for (last = 0; last < 2; last++) {
1272 if (last == 0) {
1273 start = 0;
1274 end = rl->last;
1275 } else {
1276 start = rl->last;
1277 end = rl->n;
1278 }
1279
1280 memset(max_level, 0, MAX_RUN + 1);
1281 memset(max_run, 0, MAX_LEVEL + 1);
1282 memset(index_run, rl->n, MAX_RUN + 1);
1283 for (i = start; i < end; i++) {
1284 run = rl->table_run[i];
1285 level = rl->table_level[i];
1286 if (index_run[run] == rl->n)
1287 index_run[run] = i;
1288 if (level > max_level[run])
1289 max_level[run] = level;
1290 if (run > max_run[level])
1291 max_run[level] = run;
1292 }
1293 if (static_store)
1294 rl->max_level[last] = static_store[last];
1295 else
1296 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1297 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1298 if (static_store)
1299 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1300 else
1301 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1302 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1303 if (static_store)
1304 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1305 else
1306 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1307 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1308 }
1309 }
1310
1311 av_cold void ff_init_vlc_rl(RLTable *rl)
1312 {
1313 int i, q;
1314
1315 for (q = 0; q < 32; q++) {
1316 int qmul = q * 2;
1317 int qadd = (q - 1) | 1;
1318
1319 if (q == 0) {
1320 qmul = 1;
1321 qadd = 0;
1322 }
1323 for (i = 0; i < rl->vlc.table_size; i++) {
1324 int code = rl->vlc.table[i][0];
1325 int len = rl->vlc.table[i][1];
1326 int level, run;
1327
1328 if (len == 0) { // illegal code
1329 run = 66;
1330 level = MAX_LEVEL;
1331 } else if (len < 0) { // more bits needed
1332 run = 0;
1333 level = code;
1334 } else {
1335 if (code == rl->n) { // esc
1336 run = 66;
1337 level = 0;
1338 } else {
1339 run = rl->table_run[code] + 1;
1340 level = rl->table_level[code] * qmul + qadd;
1341 if (code >= rl->last) run += 192;
1342 }
1343 }
1344 rl->rl_vlc[q][i].len = len;
1345 rl->rl_vlc[q][i].level = level;
1346 rl->rl_vlc[q][i].run = run;
1347 }
1348 }
1349 }
1350
1351 static void release_unused_pictures(MpegEncContext *s)
1352 {
1353 int i;
1354
1355 /* release non reference frames */
1356 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1357 if (!s->picture[i].reference)
1358 ff_mpeg_unref_picture(s, &s->picture[i]);
1359 }
1360 }
1361
1362 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1363 {
1364 if (pic->f.buf[0] == NULL)
1365 return 1;
1366 if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1367 return 1;
1368 return 0;
1369 }
1370
1371 static int find_unused_picture(MpegEncContext *s, int shared)
1372 {
1373 int i;
1374
1375 if (shared) {
1376 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1377 if (s->picture[i].f.buf[0] == NULL)
1378 return i;
1379 }
1380 } else {
1381 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1382 if (pic_is_unused(s, &s->picture[i]))
1383 return i;
1384 }
1385 }
1386
1387 return AVERROR_INVALIDDATA;
1388 }
1389
1390 int ff_find_unused_picture(MpegEncContext *s, int shared)
1391 {
1392 int ret = find_unused_picture(s, shared);
1393
1394 if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1395 if (s->picture[ret].needs_realloc) {
1396 s->picture[ret].needs_realloc = 0;
1397 ff_free_picture_tables(&s->picture[ret]);
1398 ff_mpeg_unref_picture(s, &s->picture[ret]);
1399 }
1400 }
1401 return ret;
1402 }
1403
1404 static void update_noise_reduction(MpegEncContext *s)
1405 {
1406 int intra, i;
1407
1408 for (intra = 0; intra < 2; intra++) {
1409 if (s->dct_count[intra] > (1 << 16)) {
1410 for (i = 0; i < 64; i++) {
1411 s->dct_error_sum[intra][i] >>= 1;
1412 }
1413 s->dct_count[intra] >>= 1;
1414 }
1415
1416 for (i = 0; i < 64; i++) {
1417 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1418 s->dct_count[intra] +
1419 s->dct_error_sum[intra][i] / 2) /
1420 (s->dct_error_sum[intra][i] + 1);
1421 }
1422 }
1423 }
1424
1425 /**
1426 * generic function for encode/decode called after coding/decoding
1427 * the header and before a frame is coded/decoded.
1428 */
1429 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1430 {
1431 int i, ret;
1432 Picture *pic;
1433 s->mb_skipped = 0;
1434
1435 /* mark & release old frames */
1436 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1437 s->last_picture_ptr != s->next_picture_ptr &&
1438 s->last_picture_ptr->f.buf[0]) {
1439 ff_mpeg_unref_picture(s, s->last_picture_ptr);
1440 }
1441
1442 /* release forgotten pictures */
1443 /* if (mpeg124/h263) */
1444 if (!s->encoding) {
1445 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1446 if (&s->picture[i] != s->last_picture_ptr &&
1447 &s->picture[i] != s->next_picture_ptr &&
1448 s->picture[i].reference && !s->picture[i].needs_realloc) {
1449 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1450 av_log(avctx, AV_LOG_ERROR,
1451 "releasing zombie picture\n");
1452 ff_mpeg_unref_picture(s, &s->picture[i]);
1453 }
1454 }
1455 }
1456
1457 ff_mpeg_unref_picture(s, &s->current_picture);
1458
1459 if (!s->encoding) {
1460 release_unused_pictures(s);
1461
1462 if (s->current_picture_ptr &&
1463 s->current_picture_ptr->f.buf[0] == NULL) {
1464 // we already have a unused image
1465 // (maybe it was set before reading the header)
1466 pic = s->current_picture_ptr;
1467 } else {
1468 i = ff_find_unused_picture(s, 0);
1469 if (i < 0) {
1470 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1471 return i;
1472 }
1473 pic = &s->picture[i];
1474 }
1475
1476 pic->reference = 0;
1477 if (!s->droppable) {
1478 if (s->pict_type != AV_PICTURE_TYPE_B)
1479 pic->reference = 3;
1480 }
1481
1482 pic->f.coded_picture_number = s->coded_picture_number++;
1483
1484 if (ff_alloc_picture(s, pic, 0) < 0)
1485 return -1;
1486
1487 s->current_picture_ptr = pic;
1488 // FIXME use only the vars from current_pic
1489 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1490 if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1491 s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1492 if (s->picture_structure != PICT_FRAME)
1493 s->current_picture_ptr->f.top_field_first =
1494 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1495 }
1496 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1497 !s->progressive_sequence;
1498 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1499 }
1500
1501 s->current_picture_ptr->f.pict_type = s->pict_type;
1502 // if (s->flags && CODEC_FLAG_QSCALE)
1503 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1504 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1505
1506 if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1507 s->current_picture_ptr)) < 0)
1508 return ret;
1509
1510 if (s->pict_type != AV_PICTURE_TYPE_B) {
1511 s->last_picture_ptr = s->next_picture_ptr;
1512 if (!s->droppable)
1513 s->next_picture_ptr = s->current_picture_ptr;
1514 }
1515 av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1516 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1517 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1518 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1519 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1520 s->pict_type, s->droppable);
1521
1522 if ((s->last_picture_ptr == NULL ||
1523 s->last_picture_ptr->f.buf[0] == NULL) &&
1524 (s->pict_type != AV_PICTURE_TYPE_I ||
1525 s->picture_structure != PICT_FRAME)) {
1526 int h_chroma_shift, v_chroma_shift;
1527 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1528 &h_chroma_shift, &v_chroma_shift);
1529 if (s->pict_type != AV_PICTURE_TYPE_I)
1530 av_log(avctx, AV_LOG_ERROR,
1531 "warning: first frame is no keyframe\n");
1532 else if (s->picture_structure != PICT_FRAME)
1533 av_log(avctx, AV_LOG_INFO,
1534 "allocate dummy last picture for field based first keyframe\n");
1535
1536 /* Allocate a dummy frame */
1537 i = ff_find_unused_picture(s, 0);
1538 if (i < 0) {
1539 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1540 return i;
1541 }
1542 s->last_picture_ptr = &s->picture[i];
1543
1544 s->last_picture_ptr->reference = 3;
1545 s->last_picture_ptr->f.pict_type = AV_PICTURE_TYPE_I;
1546
1547 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1548 s->last_picture_ptr = NULL;
1549 return -1;
1550 }
1551
1552 memset(s->last_picture_ptr->f.data[0], 0,
1553 avctx->height * s->last_picture_ptr->f.linesize[0]);
1554 memset(s->last_picture_ptr->f.data[1], 0x80,
1555 (avctx->height >> v_chroma_shift) *
1556 s->last_picture_ptr->f.linesize[1]);
1557 memset(s->last_picture_ptr->f.data[2], 0x80,
1558 (avctx->height >> v_chroma_shift) *
1559 s->last_picture_ptr->f.linesize[2]);
1560
1561 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1562 ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1563 }
1564 if ((s->next_picture_ptr == NULL ||
1565 s->next_picture_ptr->f.buf[0] == NULL) &&
1566 s->pict_type == AV_PICTURE_TYPE_B) {
1567 /* Allocate a dummy frame */
1568 i = ff_find_unused_picture(s, 0);
1569 if (i < 0) {
1570 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1571 return i;
1572 }
1573 s->next_picture_ptr = &s->picture[i];
1574
1575 s->next_picture_ptr->reference = 3;
1576 s->next_picture_ptr->f.pict_type = AV_PICTURE_TYPE_I;
1577
1578 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1579 s->next_picture_ptr = NULL;
1580 return -1;
1581 }
1582 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1583 ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1584 }
1585
1586 if (s->last_picture_ptr) {
1587 ff_mpeg_unref_picture(s, &s->last_picture);
1588 if (s->last_picture_ptr->f.buf[0] &&
1589 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1590 s->last_picture_ptr)) < 0)
1591 return ret;
1592 }
1593 if (s->next_picture_ptr) {
1594 ff_mpeg_unref_picture(s, &s->next_picture);
1595 if (s->next_picture_ptr->f.buf[0] &&
1596 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1597 s->next_picture_ptr)) < 0)
1598 return ret;
1599 }
1600
1601 if (s->pict_type != AV_PICTURE_TYPE_I &&
1602 !(s->last_picture_ptr && s->last_picture_ptr->f.buf[0])) {
1603 av_log(s, AV_LOG_ERROR,
1604 "Non-reference picture received and no reference available\n");
1605 return AVERROR_INVALIDDATA;
1606 }
1607
1608 if (s->picture_structure!= PICT_FRAME) {
1609 int i;
1610 for (i = 0; i < 4; i++) {
1611 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1612 s->current_picture.f.data[i] +=
1613 s->current_picture.f.linesize[i];
1614 }
1615 s->current_picture.f.linesize[i] *= 2;
1616 s->last_picture.f.linesize[i] *= 2;
1617 s->next_picture.f.linesize[i] *= 2;
1618 }
1619 }
1620
1621 s->err_recognition = avctx->err_recognition;
1622
1623 /* set dequantizer, we can't do it during init as
1624 * it might change for mpeg4 and we can't do it in the header
1625 * decode as init is not called for mpeg4 there yet */
1626 if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1627 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1628 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1629 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1630 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1631 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1632 } else {
1633 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1634 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1635 }
1636
1637 if (s->dct_error_sum) {
1638 assert(s->avctx->noise_reduction && s->encoding);
1639 update_noise_reduction(s);
1640 }
1641
1642 #if FF_API_XVMC
1643 FF_DISABLE_DEPRECATION_WARNINGS
1644 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1645 return ff_xvmc_field_start(s, avctx);
1646 FF_ENABLE_DEPRECATION_WARNINGS
1647 #endif /* FF_API_XVMC */
1648
1649 return 0;
1650 }
1651
1652 /* called after a frame has been decoded. */
1653 void ff_MPV_frame_end(MpegEncContext *s)
1654 {
1655 #if FF_API_XVMC
1656 FF_DISABLE_DEPRECATION_WARNINGS
1657 /* redraw edges for the frame if decoding didn't complete */
1658 // just to make sure that all data is rendered.
1659 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1660 ff_xvmc_field_end(s);
1661 } else
1662 FF_ENABLE_DEPRECATION_WARNINGS
1663 #endif /* FF_API_XVMC */
1664 if (s->er.error_count &&
1665 !s->avctx->hwaccel &&
1666 s->unrestricted_mv &&
1667 s->current_picture.reference &&
1668 !s->intra_only &&
1669 !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1670 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1671 int hshift = desc->log2_chroma_w;
1672 int vshift = desc->log2_chroma_h;
1673 s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1674 s->h_edge_pos, s->v_edge_pos,
1675 EDGE_WIDTH, EDGE_WIDTH,
1676 EDGE_TOP | EDGE_BOTTOM);
1677 s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1678 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1679 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1680 EDGE_TOP | EDGE_BOTTOM);
1681 s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1682 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1683 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1684 EDGE_TOP | EDGE_BOTTOM);
1685 }
1686
1687 emms_c();
1688
1689 if (s->current_picture.reference)
1690 ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1691 }
1692
1693 /**
1694 * Print debugging info for the given picture.
1695 */
1696 void ff_print_debug_info(MpegEncContext *s, Picture *p)
1697 {
1698 AVFrame *pict;
1699 if (s->avctx->hwaccel || !p || !p->mb_type)
1700 return;
1701 pict = &p->f;
1702
1703 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1704 int x,y;
1705
1706 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1707 switch (pict->pict_type) {
1708 case AV_PICTURE_TYPE_I:
1709 av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1710 break;
1711 case AV_PICTURE_TYPE_P:
1712 av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1713 break;
1714 case AV_PICTURE_TYPE_B:
1715 av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1716 break;
1717 case AV_PICTURE_TYPE_S:
1718 av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1719 break;
1720 case AV_PICTURE_TYPE_SI:
1721 av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1722 break;
1723 case AV_PICTURE_TYPE_SP:
1724 av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1725 break;
1726 }
1727 for (y = 0; y < s->mb_height; y++) {
1728 for (x = 0; x < s->mb_width; x++) {
1729 if (s->avctx->debug & FF_DEBUG_SKIP) {
1730 int count = s->mbskip_table[x + y * s->mb_stride];
1731 if (count > 9)
1732 count = 9;
1733 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1734 }
1735 if (s->avctx->debug & FF_DEBUG_QP) {
1736 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1737 p->qscale_table[x + y * s->mb_stride]);
1738 }
1739 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1740 int mb_type = p->mb_type[x + y * s->mb_stride];
1741 // Type & MV direction
1742 if (IS_PCM(mb_type))
1743 av_log(s->avctx, AV_LOG_DEBUG, "P");
1744 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1745 av_log(s->avctx, AV_LOG_DEBUG, "A");
1746 else if (IS_INTRA4x4(mb_type))
1747 av_log(s->avctx, AV_LOG_DEBUG, "i");
1748 else if (IS_INTRA16x16(mb_type))
1749 av_log(s->avctx, AV_LOG_DEBUG, "I");
1750 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1751 av_log(s->avctx, AV_LOG_DEBUG, "d");
1752 else if (IS_DIRECT(mb_type))
1753 av_log(s->avctx, AV_LOG_DEBUG, "D");
1754 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1755 av_log(s->avctx, AV_LOG_DEBUG, "g");
1756 else if (IS_GMC(mb_type))
1757 av_log(s->avctx, AV_LOG_DEBUG, "G");
1758 else if (IS_SKIP(mb_type))
1759 av_log(s->avctx, AV_LOG_DEBUG, "S");
1760 else if (!USES_LIST(mb_type, 1))
1761 av_log(s->avctx, AV_LOG_DEBUG, ">");
1762 else if (!USES_LIST(mb_type, 0))
1763 av_log(s->avctx, AV_LOG_DEBUG, "<");
1764 else {
1765 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1766 av_log(s->avctx, AV_LOG_DEBUG, "X");
1767 }
1768
1769 // segmentation
1770 if (IS_8X8(mb_type))
1771 av_log(s->avctx, AV_LOG_DEBUG, "+");
1772 else if (IS_16X8(mb_type))
1773 av_log(s->avctx, AV_LOG_DEBUG, "-");
1774 else if (IS_8X16(mb_type))
1775 av_log(s->avctx, AV_LOG_DEBUG, "|");
1776 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1777 av_log(s->avctx, AV_LOG_DEBUG, " ");
1778 else
1779 av_log(s->avctx, AV_LOG_DEBUG, "?");
1780
1781
1782 if (IS_INTERLACED(mb_type))
1783 av_log(s->avctx, AV_LOG_DEBUG, "=");
1784 else
1785 av_log(s->avctx, AV_LOG_DEBUG, " ");
1786 }
1787 }
1788 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1789 }
1790 }
1791 }
1792
1793 /**
1794 * find the lowest MB row referenced in the MVs
1795 */
1796 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1797 {
1798 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1799 int my, off, i, mvs;
1800
1801 if (s->picture_structure != PICT_FRAME || s->mcsel)
1802 goto unhandled;
1803
1804 switch (s->mv_type) {
1805 case MV_TYPE_16X16:
1806 mvs = 1;
1807 break;
1808 case MV_TYPE_16X8:
1809 mvs = 2;
1810 break;
1811 case MV_TYPE_8X8:
1812 mvs = 4;
1813 break;
1814 default:
1815 goto unhandled;
1816 }
1817
1818 for (i = 0; i < mvs; i++) {
1819 my = s->mv[dir][i][1]<<qpel_shift;
1820 my_max = FFMAX(my_max, my);
1821 my_min = FFMIN(my_min, my);
1822 }
1823
1824 off = (FFMAX(-my_min, my_max) + 63) >> 6;
1825
1826 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1827 unhandled:
1828 return s->mb_height-1;
1829 }
1830
1831 /* put block[] to dest[] */
1832 static inline void put_dct(MpegEncContext *s,
1833 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1834 {
1835 s->dct_unquantize_intra(s, block, i, qscale);
1836 s->dsp.idct_put (dest, line_size, block);
1837 }
1838
1839 /* add block[] to dest[] */
1840 static inline void add_dct(MpegEncContext *s,
1841 int16_t *block, int i, uint8_t *dest, int line_size)
1842 {
1843 if (s->block_last_index[i] >= 0) {
1844 s->dsp.idct_add (dest, line_size, block);
1845 }
1846 }
1847
1848 static inline void add_dequant_dct(MpegEncContext *s,
1849 int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1850 {
1851 if (s->block_last_index[i] >= 0) {
1852 s->dct_unquantize_inter(s, block, i, qscale);
1853
1854 s->dsp.idct_add (dest, line_size, block);
1855 }
1856 }
1857
1858 /**
1859 * Clean dc, ac, coded_block for the current non-intra MB.
1860 */
1861 void ff_clean_intra_table_entries(MpegEncContext *s)
1862 {
1863 int wrap = s->b8_stride;
1864 int xy = s->block_index[0];
1865
1866 s->dc_val[0][xy ] =
1867 s->dc_val[0][xy + 1 ] =
1868 s->dc_val[0][xy + wrap] =
1869 s->dc_val[0][xy + 1 + wrap] = 1024;
1870 /* ac pred */
1871 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1872 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1873 if (s->msmpeg4_version>=3) {
1874 s->coded_block[xy ] =
1875 s->coded_block[xy + 1 ] =
1876 s->coded_block[xy + wrap] =
1877 s->coded_block[xy + 1 + wrap] = 0;
1878 }
1879 /* chroma */
1880 wrap = s->mb_stride;
1881 xy = s->mb_x + s->mb_y * wrap;
1882 s->dc_val[1][xy] =
1883 s->dc_val[2][xy] = 1024;
1884 /* ac pred */
1885 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1886 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1887
1888 s->mbintra_table[xy]= 0;
1889 }
1890
1891 /* generic function called after a macroblock has been parsed by the
1892 decoder or after it has been encoded by the encoder.
1893
1894 Important variables used:
1895 s->mb_intra : true if intra macroblock
1896 s->mv_dir : motion vector direction
1897 s->mv_type : motion vector type
1898 s->mv : motion vector
1899 s->interlaced_dct : true if interlaced dct used (mpeg2)
1900 */
1901 static av_always_inline
1902 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
1903 int is_mpeg12)
1904 {
1905 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1906
1907 #if FF_API_XVMC
1908 FF_DISABLE_DEPRECATION_WARNINGS
1909 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1910 ff_xvmc_decode_mb(s);//xvmc uses pblocks
1911 return;
1912 }
1913 FF_ENABLE_DEPRECATION_WARNINGS
1914 #endif /* FF_API_XVMC */
1915
1916 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1917 /* print DCT coefficients */
1918 int i,j;
1919 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1920 for(i=0; i<6; i++){
1921 for(j=0; j<64; j++){
1922 av_log(s->avctx, AV_LOG_DEBUG, "%5d", block[i][s->dsp.idct_permutation[j]]);
1923 }
1924 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1925 }
1926 }
1927
1928 s->current_picture.qscale_table[mb_xy] = s->qscale;
1929
1930 /* update DC predictors for P macroblocks */
1931 if (!s->mb_intra) {
1932 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1933 if(s->mbintra_table[mb_xy])
1934 ff_clean_intra_table_entries(s);
1935 } else {
1936 s->last_dc[0] =
1937 s->last_dc[1] =
1938 s->last_dc[2] = 128 << s->intra_dc_precision;
1939 }
1940 }
1941 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1942 s->mbintra_table[mb_xy]=1;
1943
1944 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
1945 uint8_t *dest_y, *dest_cb, *dest_cr;
1946 int dct_linesize, dct_offset;
1947 op_pixels_func (*op_pix)[4];
1948 qpel_mc_func (*op_qpix)[16];
1949 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
1950 const int uvlinesize = s->current_picture.f.linesize[1];
1951 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
1952 const int block_size = 8;
1953
1954 /* avoid copy if macroblock skipped in last frame too */
1955 /* skip only during decoding as we might trash the buffers during encoding a bit */
1956 if(!s->encoding){
1957 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1958
1959 if (s->mb_skipped) {
1960 s->mb_skipped= 0;
1961 assert(s->pict_type!=AV_PICTURE_TYPE_I);
1962 *mbskip_ptr = 1;
1963 } else if(!s->current_picture.reference) {
1964 *mbskip_ptr = 1;
1965 } else{
1966 *mbskip_ptr = 0; /* not skipped */
1967 }
1968 }
1969
1970 dct_linesize = linesize << s->interlaced_dct;
1971 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
1972
1973 if(readable){
1974 dest_y= s->dest[0];
1975 dest_cb= s->dest[1];
1976 dest_cr= s->dest[2];
1977 }else{
1978 dest_y = s->b_scratchpad;
1979 dest_cb= s->b_scratchpad+16*linesize;
1980 dest_cr= s->b_scratchpad+32*linesize;
1981 }
1982
1983 if (!s->mb_intra) {
1984 /* motion handling */
1985 /* decoding or more than one mb_type (MC was already done otherwise) */
1986 if(!s->encoding){
1987
1988 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
1989 if (s->mv_dir & MV_DIR_FORWARD) {
1990 ff_thread_await_progress(&s->last_picture_ptr->tf,
1991 ff_MPV_lowest_referenced_row(s, 0),
1992 0);
1993 }
1994 if (s->mv_dir & MV_DIR_BACKWARD) {
1995 ff_thread_await_progress(&s->next_picture_ptr->tf,
1996 ff_MPV_lowest_referenced_row(s, 1),
1997 0);
1998 }
1999 }
2000
2001 op_qpix= s->me.qpel_put;
2002 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2003 op_pix = s->hdsp.put_pixels_tab;
2004 }else{
2005 op_pix = s->hdsp.put_no_rnd_pixels_tab;
2006 }
2007 if (s->mv_dir & MV_DIR_FORWARD) {
2008 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2009 op_pix = s->hdsp.avg_pixels_tab;
2010 op_qpix= s->me.qpel_avg;
2011 }
2012 if (s->mv_dir & MV_DIR_BACKWARD) {
2013 ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2014 }
2015 }
2016
2017 /* skip dequant / idct if we are really late ;) */
2018 if(s->avctx->skip_idct){
2019 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2020 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2021 || s->avctx->skip_idct >= AVDISCARD_ALL)
2022 goto skip_idct;
2023 }
2024
2025 /* add dct residue */
2026 if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2027 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2028 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2029 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2030 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2031 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2032
2033 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2034 if (s->chroma_y_shift){
2035 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2036 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2037 }else{
2038 dct_linesize >>= 1;
2039 dct_offset >>=1;
2040 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2041 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2042 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2043 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2044 }
2045 }
2046 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2047 add_dct(s, block[0], 0, dest_y , dct_linesize);
2048 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2049 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2050 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2051
2052 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2053 if(s->chroma_y_shift){//Chroma420
2054 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2055 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2056 }else{
2057 //chroma422
2058 dct_linesize = uvlinesize << s->interlaced_dct;
2059 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2060
2061 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2062 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2063 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2064 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2065 if(!s->chroma_x_shift){//Chroma444
2066 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2067 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2068 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2069 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2070 }
2071 }
2072 }//fi gray
2073 }
2074 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2075 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2076 }
2077 } else {
2078 /* dct only in intra block */
2079 if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2080 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2081 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2082 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2083 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2084
2085 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2086 if(s->chroma_y_shift){
2087 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2088 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2089 }else{
2090 dct_offset >>=1;
2091 dct_linesize >>=1;
2092 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2093 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2094 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2095 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2096 }
2097 }
2098 }else{
2099 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2100 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2101 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2102 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2103
2104 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2105 if(s->chroma_y_shift){
2106 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2107 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2108 }else{
2109
2110 dct_linesize = uvlinesize << s->interlaced_dct;
2111 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2112
2113 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2114 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2115 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2116 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2117 if(!s->chroma_x_shift){//Chroma444
2118 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2119 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2120 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2121 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2122 }
2123 }
2124 }//gray
2125 }
2126 }
2127 skip_idct:
2128 if(!readable){
2129 s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2130 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2131 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2132 }
2133 }
2134 }
2135
2136 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2137 #if !CONFIG_SMALL
2138 if(s->out_format == FMT_MPEG1) {
2139 MPV_decode_mb_internal(s, block, 1);
2140 } else
2141 #endif
2142 MPV_decode_mb_internal(s, block, 0);
2143 }
2144
2145 /**
2146 * @param h is the normal height, this will be reduced automatically if needed for the last row
2147 */
2148 void ff_draw_horiz_band(AVCodecContext *avctx, DSPContext *dsp, Picture *cur,
2149 Picture *last, int y, int h, int picture_structure,
2150 int first_field, int draw_edges, int low_delay,
2151 int v_edge_pos, int h_edge_pos)
2152 {
2153 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2154 int hshift = desc->log2_chroma_w;
2155 int vshift = desc->log2_chroma_h;
2156 const int field_pic = picture_structure != PICT_FRAME;
2157 if(field_pic){
2158 h <<= 1;
2159 y <<= 1;
2160 }
2161
2162 if (!avctx->hwaccel &&
2163 draw_edges &&
2164 cur->reference &&
2165 !(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
2166 int *linesize = cur->f.linesize;
2167 int sides = 0, edge_h;
2168 if (y==0) sides |= EDGE_TOP;
2169 if (y + h >= v_edge_pos)
2170 sides |= EDGE_BOTTOM;
2171
2172 edge_h= FFMIN(h, v_edge_pos - y);
2173
2174 dsp->draw_edges(cur->f.data[0] + y * linesize[0],
2175 linesize[0], h_edge_pos, edge_h,
2176 EDGE_WIDTH, EDGE_WIDTH, sides);
2177 dsp->draw_edges(cur->f.data[1] + (y >> vshift) * linesize[1],
2178 linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2179 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2180 dsp->draw_edges(cur->f.data[2] + (y >> vshift) * linesize[2],
2181 linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2182 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2183 }
2184
2185 h = FFMIN(h, avctx->height - y);
2186
2187 if(field_pic && first_field && !(avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2188
2189 if (avctx->draw_horiz_band) {
2190 AVFrame *src;
2191 int offset[AV_NUM_DATA_POINTERS];
2192 int i;
2193
2194 if(cur->f.pict_type == AV_PICTURE_TYPE_B || low_delay ||
2195 (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2196 src = &cur->f;
2197 else if (last)
2198 src = &last->f;
2199 else
2200 return;
2201
2202 if (cur->f.pict_type == AV_PICTURE_TYPE_B &&
2203 picture_structure == PICT_FRAME &&
2204 avctx->codec_id != AV_CODEC_ID_SVQ3) {
2205 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2206 offset[i] = 0;
2207 }else{
2208 offset[0]= y * src->linesize[0];
2209 offset[1]=
2210 offset[2]= (y >> vshift) * src->linesize[1];
2211 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2212 offset[i] = 0;
2213 }
2214
2215 emms_c();
2216
2217 avctx->draw_horiz_band(avctx, src, offset,
2218 y, picture_structure, h);
2219 }
2220 }
2221
2222 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2223 {
2224 int draw_edges = s->unrestricted_mv && !s->intra_only;
2225 ff_draw_horiz_band(s->avctx, &s->dsp, &s->current_picture,
2226 &s->last_picture, y, h, s->picture_structure,
2227 s->first_field, draw_edges, s->low_delay,
2228 s->v_edge_pos, s->h_edge_pos);
2229 }
2230
2231 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2232 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2233 const int uvlinesize = s->current_picture.f.linesize[1];
2234 const int mb_size= 4;
2235
2236 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2237 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2238 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2239 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2240 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2241 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;
2242 //block_index is not used by mpeg2, so it is not affected by chroma_format
2243
2244 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2245 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2246 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2247
2248 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2249 {
2250 if(s->picture_structure==PICT_FRAME){
2251 s->dest[0] += s->mb_y * linesize << mb_size;
2252 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2253 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2254 }else{
2255 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2256 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2257 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2258 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2259 }
2260 }
2261 }
2262
2263 /**
2264 * Permute an 8x8 block.
2265 * @param block the block which will be permuted according to the given permutation vector
2266 * @param permutation the permutation vector
2267 * @param last the last non zero coefficient in scantable order, used to speed the permutation up
2268 * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
2269 * (inverse) permutated to scantable order!
2270 */
2271 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
2272 {
2273 int i;
2274 int16_t temp[64];
2275
2276 if(last<=0) return;
2277 //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
2278
2279 for(i=0; i<=last; i++){
2280 const int j= scantable[i];
2281 temp[j]= block[j];
2282 block[j]=0;
2283 }
2284
2285 for(i=0; i<=last; i++){
2286 const int j= scantable[i];
2287 const int perm_j= permutation[j];
2288 block[perm_j]= temp[j];
2289 }
2290 }
2291
2292 void ff_mpeg_flush(AVCodecContext *avctx){
2293 int i;
2294 MpegEncContext *s = avctx->priv_data;
2295
2296 if(s==NULL || s->picture==NULL)
2297 return;
2298
2299 for (i = 0; i < MAX_PICTURE_COUNT; i++)
2300 ff_mpeg_unref_picture(s, &s->picture[i]);
2301 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2302
2303 ff_mpeg_unref_picture(s, &s->current_picture);
2304 ff_mpeg_unref_picture(s, &s->last_picture);
2305 ff_mpeg_unref_picture(s, &s->next_picture);
2306
2307 s->mb_x= s->mb_y= 0;
2308
2309 s->parse_context.state= -1;
2310 s->parse_context.frame_start_found= 0;
2311 s->parse_context.overread= 0;
2312 s->parse_context.overread_index= 0;
2313 s->parse_context.index= 0;
2314 s->parse_context.last_index= 0;
2315 s->bitstream_buffer_size=0;
2316 s->pp_time=0;
2317 }
2318
2319 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2320 int16_t *block, int n, int qscale)
2321 {
2322 int i, level, nCoeffs;
2323 const uint16_t *quant_matrix;
2324
2325 nCoeffs= s->block_last_index[n];
2326
2327 if (n < 4)
2328 block[0] = block[0] * s->y_dc_scale;
2329 else
2330 block[0] = block[0] * s->c_dc_scale;
2331 /* XXX: only mpeg1 */
2332 quant_matrix = s->intra_matrix;
2333 for(i=1;i<=nCoeffs;i++) {
2334 int j= s->intra_scantable.permutated[i];
2335 level = block[j];
2336 if (level) {
2337 if (level < 0) {
2338 level = -level;
2339 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2340 level = (level - 1) | 1;
2341 level = -level;
2342 } else {
2343 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2344 level = (level - 1) | 1;
2345 }
2346 block[j] = level;
2347 }
2348 }
2349 }
2350
2351 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2352 int16_t *block, int n, int qscale)
2353 {
2354 int i, level, nCoeffs;
2355 const uint16_t *quant_matrix;
2356
2357 nCoeffs= s->block_last_index[n];
2358
2359 quant_matrix = s->inter_matrix;
2360 for(i=0; i<=nCoeffs; i++) {
2361 int j= s->intra_scantable.permutated[i];
2362 level = block[j];
2363 if (level) {
2364 if (level < 0) {
2365 level = -level;
2366 level = (((level << 1) + 1) * qscale *
2367 ((int) (quant_matrix[j]))) >> 4;
2368 level = (level - 1) | 1;
2369 level = -level;
2370 } else {
2371 level = (((level << 1) + 1) * qscale *
2372 ((int) (quant_matrix[j]))) >> 4;
2373 level = (level - 1) | 1;
2374 }
2375 block[j] = level;
2376 }
2377 }
2378 }
2379
2380 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2381 int16_t *block, int n, int qscale)
2382 {
2383 int i, level, nCoeffs;
2384 const uint16_t *quant_matrix;
2385
2386 if(s->alternate_scan) nCoeffs= 63;
2387 else nCoeffs= s->block_last_index[n];
2388
2389 if (n < 4)
2390 block[0] = block[0] * s->y_dc_scale;
2391 else
2392 block[0] = block[0] * s->c_dc_scale;
2393 quant_matrix = s->intra_matrix;
2394 for(i=1;i<=nCoeffs;i++) {
2395 int j= s->intra_scantable.permutated[i];
2396 level = block[j];
2397 if (level) {
2398 if (level < 0) {
2399 level = -level;
2400 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2401 level = -level;
2402 } else {
2403 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2404 }
2405 block[j] = level;
2406 }
2407 }
2408 }
2409
2410 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2411 int16_t *block, int n, int qscale)
2412 {
2413 int i, level, nCoeffs;
2414 const uint16_t *quant_matrix;
2415 int sum=-1;
2416
2417 if(s->alternate_scan) nCoeffs= 63;
2418 else nCoeffs= s->block_last_index[n];
2419
2420 if (n < 4)
2421 block[0] = block[0] * s->y_dc_scale;
2422 else
2423 block[0] = block[0] * s->c_dc_scale;
2424 quant_matrix = s->intra_matrix;
2425 for(i=1;i<=nCoeffs;i++) {
2426 int j= s->intra_scantable.permutated[i];
2427 level = block[j];
2428 if (level) {
2429 if (level < 0) {
2430 level = -level;
2431 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2432 level = -level;
2433 } else {
2434 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2435 }
2436 block[j] = level;
2437 sum+=level;
2438 }
2439 }
2440 block[63]^=sum&1;
2441 }
2442
2443 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2444 int16_t *block, int n, int qscale)
2445 {
2446 int i, level, nCoeffs;
2447 const uint16_t *quant_matrix;
2448 int sum=-1;
2449
2450 if(s->alternate_scan) nCoeffs= 63;
2451 else nCoeffs= s->block_last_index[n];
2452
2453 quant_matrix = s->inter_matrix;
2454 for(i=0; i<=nCoeffs; i++) {
2455 int j= s->intra_scantable.permutated[i];
2456 level = block[j];
2457 if (level) {
2458 if (level < 0) {
2459 level = -level;
2460 level = (((level << 1) + 1) * qscale *
2461 ((int) (quant_matrix[j]))) >> 4;
2462 level = -level;
2463 } else {
2464 level = (((level << 1) + 1) * qscale *
2465 ((int) (quant_matrix[j]))) >> 4;
2466 }
2467 block[j] = level;
2468 sum+=level;
2469 }
2470 }
2471 block[63]^=sum&1;
2472 }
2473
2474 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2475 int16_t *block, int n, int qscale)
2476 {
2477 int i, level, qmul, qadd;
2478 int nCoeffs;
2479
2480 assert(s->block_last_index[n]>=0);
2481
2482 qmul = qscale << 1;
2483
2484 if (!s->h263_aic) {
2485 if (n < 4)
2486 block[0] = block[0] * s->y_dc_scale;
2487 else
2488 block[0] = block[0] * s->c_dc_scale;
2489 qadd = (qscale - 1) | 1;
2490 }else{
2491 qadd = 0;
2492 }
2493 if(s->ac_pred)
2494 nCoeffs=63;
2495 else
2496 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2497
2498 for(i=1; i<=nCoeffs; i++) {
2499 level = block[i];
2500 if (level) {
2501 if (level < 0) {
2502 level = level * qmul - qadd;
2503 } else {
2504 level = level * qmul + qadd;
2505 }
2506 block[i] = level;
2507 }
2508 }
2509 }
2510
2511 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2512 int16_t *block, int n, int qscale)
2513 {
2514 int i, level, qmul, qadd;
2515 int nCoeffs;
2516
2517 assert(s->block_last_index[n]>=0);
2518
2519 qadd = (qscale - 1) | 1;
2520 qmul = qscale << 1;
2521
2522 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2523
2524 for(i=0; i<=nCoeffs; i++) {
2525 level = block[i];
2526 if (level) {
2527 if (level < 0) {
2528 level = level * qmul - qadd;
2529 } else {
2530 level = level * qmul + qadd;
2531 }
2532 block[i] = level;
2533 }
2534 }
2535 }
2536
2537 /**
2538 * set qscale and update qscale dependent variables.
2539 */
2540 void ff_set_qscale(MpegEncContext * s, int qscale)
2541 {
2542 if (qscale < 1)
2543 qscale = 1;
2544 else if (qscale > 31)
2545 qscale = 31;
2546
2547 s->qscale = qscale;
2548 s->chroma_qscale= s->chroma_qscale_table[qscale];
2549
2550 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2551 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2552 }
2553
2554 void ff_MPV_report_decode_progress(MpegEncContext *s)
2555 {
2556 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2557 ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2558 }
2559
2560 #if CONFIG_ERROR_RESILIENCE
2561 void ff_mpeg_er_frame_start(MpegEncContext *s)
2562 {
2563 ERContext *er = &s->er;
2564
2565 er->cur_pic = s->current_picture_ptr;
2566 er->last_pic = s->last_picture_ptr;
2567 er->next_pic = s->next_picture_ptr;
2568
2569 er->pp_time = s->pp_time;
2570 er->pb_time = s->pb_time;
2571 er->quarter_sample = s->quarter_sample;
2572 er->partitioned_frame = s->partitioned_frame;
2573
2574 ff_er_frame_start(er);
2575 }
2576 #endif /* CONFIG_ERROR_RESILIENCE */