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>
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "libavutil/intmath.h"
31 #include "libavutil/imgutils.h"
35 #include "mpegvideo.h"
36 #include "mpegvideo_common.h"
40 #include "xvmc_internal.h"
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58 DCTELEM *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60 DCTELEM *block, int n, int qscale);
63 /* enable all paranoid tests for rounding, overflows, etc... */
69 static const uint8_t ff_default_chroma_qscale_table[32] = {
70 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
71 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
72 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
75 const uint8_t ff_mpeg1_dc_scale_table[128] = {
76 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
77 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
80 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
81 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
83 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
84 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
87 static const uint8_t mpeg2_dc_scale_table1[128] = {
88 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
95 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
96 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
99 static const uint8_t mpeg2_dc_scale_table2[128] = {
100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
101 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
111 static const uint8_t mpeg2_dc_scale_table3[128] = {
112 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
113 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
116 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
117 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
119 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
120 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
123 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
124 ff_mpeg1_dc_scale_table,
125 mpeg2_dc_scale_table1,
126 mpeg2_dc_scale_table2,
127 mpeg2_dc_scale_table3,
130 const enum PixelFormat ff_pixfmt_list_420[] = {
135 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
143 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *restrict p,
145 uint32_t * restrict state)
153 for (i = 0; i < 3; i++) {
154 uint32_t tmp = *state << 8;
155 *state = tmp + *(p++);
156 if (tmp == 0x100 || p == end)
161 if (p[-1] > 1 ) p += 3;
162 else if (p[-2] ) p += 2;
163 else if (p[-3]|(p[-1]-1)) p++;
170 p = FFMIN(p, end) - 4;
176 /* init common dct for both encoder and decoder */
177 av_cold int ff_dct_common_init(MpegEncContext *s)
179 dsputil_init(&s->dsp, s->avctx);
181 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
182 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
183 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
184 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
185 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
186 if (s->flags & CODEC_FLAG_BITEXACT)
187 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
188 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
191 MPV_common_init_mmx(s);
193 MPV_common_init_axp(s);
195 MPV_common_init_mlib(s);
197 MPV_common_init_mmi(s);
199 MPV_common_init_arm(s);
201 MPV_common_init_altivec(s);
203 MPV_common_init_bfin(s);
206 /* load & permutate scantables
207 * note: only wmv uses different ones
209 if (s->alternate_scan) {
210 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
211 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
213 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
214 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
216 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
217 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
222 void ff_copy_picture(Picture *dst, Picture *src)
225 dst->f.type = FF_BUFFER_TYPE_COPY;
229 * Release a frame buffer
231 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
233 /* Windows Media Image codecs allocate internal buffers with different
234 * dimensions; ignore user defined callbacks for these
236 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
237 ff_thread_release_buffer(s->avctx, (AVFrame *) pic);
239 avcodec_default_release_buffer(s->avctx, (AVFrame *) pic);
240 av_freep(&pic->f.hwaccel_picture_private);
244 * Allocate a frame buffer
246 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
250 if (s->avctx->hwaccel) {
251 assert(!pic->f.hwaccel_picture_private);
252 if (s->avctx->hwaccel->priv_data_size) {
253 pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
254 if (!pic->f.hwaccel_picture_private) {
255 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
261 if (s->codec_id != CODEC_ID_WMV3IMAGE && s->codec_id != CODEC_ID_VC1IMAGE)
262 r = ff_thread_get_buffer(s->avctx, (AVFrame *) pic);
264 r = avcodec_default_get_buffer(s->avctx, (AVFrame *) pic);
266 if (r < 0 || !pic->f.type || !pic->f.data[0]) {
267 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
268 r, pic->f.type, pic->f.data[0]);
269 av_freep(&pic->f.hwaccel_picture_private);
273 if (s->linesize && (s->linesize != pic->f.linesize[0] ||
274 s->uvlinesize != pic->f.linesize[1])) {
275 av_log(s->avctx, AV_LOG_ERROR,
276 "get_buffer() failed (stride changed)\n");
277 free_frame_buffer(s, pic);
281 if (pic->f.linesize[1] != pic->f.linesize[2]) {
282 av_log(s->avctx, AV_LOG_ERROR,
283 "get_buffer() failed (uv stride mismatch)\n");
284 free_frame_buffer(s, pic);
292 * Allocate a Picture.
293 * The pixels are allocated/set by calling get_buffer() if shared = 0
295 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
297 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
299 // the + 1 is needed so memset(,,stride*height) does not sig11
301 const int mb_array_size = s->mb_stride * s->mb_height;
302 const int b8_array_size = s->b8_stride * s->mb_height * 2;
303 const int b4_array_size = s->b4_stride * s->mb_height * 4;
308 assert(pic->f.data[0]);
309 assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
310 pic->f.type = FF_BUFFER_TYPE_SHARED;
312 assert(!pic->f.data[0]);
314 if (alloc_frame_buffer(s, pic) < 0)
317 s->linesize = pic->f.linesize[0];
318 s->uvlinesize = pic->f.linesize[1];
321 if (pic->f.qscale_table == NULL) {
323 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
324 mb_array_size * sizeof(int16_t), fail)
325 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
326 mb_array_size * sizeof(int16_t), fail)
327 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
328 mb_array_size * sizeof(int8_t ), fail)
331 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
332 mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
333 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
334 (big_mb_num + s->mb_stride) * sizeof(uint8_t),
336 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
337 (big_mb_num + s->mb_stride) * sizeof(uint32_t),
339 pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
340 pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
341 if (s->out_format == FMT_H264) {
342 for (i = 0; i < 2; i++) {
343 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
344 2 * (b4_array_size + 4) * sizeof(int16_t),
346 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
347 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
348 4 * mb_array_size * sizeof(uint8_t), fail)
350 pic->f.motion_subsample_log2 = 2;
351 } else if (s->out_format == FMT_H263 || s->encoding ||
352 (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
353 for (i = 0; i < 2; i++) {
354 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
355 2 * (b8_array_size + 4) * sizeof(int16_t),
357 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
358 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
359 4 * mb_array_size * sizeof(uint8_t), fail)
361 pic->f.motion_subsample_log2 = 3;
363 if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
364 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
365 64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
367 pic->f.qstride = s->mb_stride;
368 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
369 1 * sizeof(AVPanScan), fail)
375 fail: // for the FF_ALLOCZ_OR_GOTO macro
377 free_frame_buffer(s, pic);
382 * Deallocate a picture.
384 static void free_picture(MpegEncContext *s, Picture *pic)
388 if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
389 free_frame_buffer(s, pic);
392 av_freep(&pic->mb_var);
393 av_freep(&pic->mc_mb_var);
394 av_freep(&pic->mb_mean);
395 av_freep(&pic->f.mbskip_table);
396 av_freep(&pic->qscale_table_base);
397 av_freep(&pic->mb_type_base);
398 av_freep(&pic->f.dct_coeff);
399 av_freep(&pic->f.pan_scan);
400 pic->f.mb_type = NULL;
401 for (i = 0; i < 2; i++) {
402 av_freep(&pic->motion_val_base[i]);
403 av_freep(&pic->f.ref_index[i]);
406 if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
407 for (i = 0; i < 4; i++) {
409 pic->f.data[i] = NULL;
415 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
417 int y_size = s->b8_stride * (2 * s->mb_height + 1);
418 int c_size = s->mb_stride * (s->mb_height + 1);
419 int yc_size = y_size + 2 * c_size;
422 // edge emu needs blocksize + filter length - 1
423 // (= 17x17 for halfpel / 21x21 for h264)
424 FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
425 (s->width + 64) * 2 * 21 * 2, fail); // (width + edge + align)*interlaced*MBsize*tolerance
427 // FIXME should be linesize instead of s->width * 2
428 // but that is not known before get_buffer()
429 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
430 (s->width + 64) * 4 * 16 * 2 * sizeof(uint8_t), fail)
431 s->me.temp = s->me.scratchpad;
432 s->rd_scratchpad = s->me.scratchpad;
433 s->b_scratchpad = s->me.scratchpad;
434 s->obmc_scratchpad = s->me.scratchpad + 16;
436 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
437 ME_MAP_SIZE * sizeof(uint32_t), fail)
438 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
439 ME_MAP_SIZE * sizeof(uint32_t), fail)
440 if (s->avctx->noise_reduction) {
441 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
442 2 * 64 * sizeof(int), fail)
445 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
446 s->block = s->blocks[0];
448 for (i = 0; i < 12; i++) {
449 s->pblocks[i] = &s->block[i];
452 if (s->out_format == FMT_H263) {
454 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
455 yc_size * sizeof(int16_t) * 16, fail);
456 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
457 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
458 s->ac_val[2] = s->ac_val[1] + c_size;
463 return -1; // free() through MPV_common_end()
466 static void free_duplicate_context(MpegEncContext *s)
471 av_freep(&s->edge_emu_buffer);
472 av_freep(&s->me.scratchpad);
476 s->obmc_scratchpad = NULL;
478 av_freep(&s->dct_error_sum);
479 av_freep(&s->me.map);
480 av_freep(&s->me.score_map);
481 av_freep(&s->blocks);
482 av_freep(&s->ac_val_base);
486 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
488 #define COPY(a) bak->a = src->a
489 COPY(edge_emu_buffer);
494 COPY(obmc_scratchpad);
501 COPY(me.map_generation);
513 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
517 // FIXME copy only needed parts
519 backup_duplicate_context(&bak, dst);
520 memcpy(dst, src, sizeof(MpegEncContext));
521 backup_duplicate_context(dst, &bak);
522 for (i = 0; i < 12; i++) {
523 dst->pblocks[i] = &dst->block[i];
525 // STOP_TIMER("update_duplicate_context")
526 // about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
529 int ff_mpeg_update_thread_context(AVCodecContext *dst,
530 const AVCodecContext *src)
532 MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
534 if (dst == src || !s1->context_initialized)
537 // FIXME can parameters change on I-frames?
538 // in that case dst may need a reinit
539 if (!s->context_initialized) {
540 memcpy(s, s1, sizeof(MpegEncContext));
543 s->picture_range_start += MAX_PICTURE_COUNT;
544 s->picture_range_end += MAX_PICTURE_COUNT;
545 s->bitstream_buffer = NULL;
546 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
551 s->avctx->coded_height = s1->avctx->coded_height;
552 s->avctx->coded_width = s1->avctx->coded_width;
553 s->avctx->width = s1->avctx->width;
554 s->avctx->height = s1->avctx->height;
556 s->coded_picture_number = s1->coded_picture_number;
557 s->picture_number = s1->picture_number;
558 s->input_picture_number = s1->input_picture_number;
560 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
561 memcpy(&s->last_picture, &s1->last_picture,
562 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
564 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
565 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
566 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
568 // Error/bug resilience
569 s->next_p_frame_damaged = s1->next_p_frame_damaged;
570 s->workaround_bugs = s1->workaround_bugs;
571 s->padding_bug_score = s1->padding_bug_score;
574 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
575 (char *) &s1->shape - (char *) &s1->time_increment_bits);
578 s->max_b_frames = s1->max_b_frames;
579 s->low_delay = s1->low_delay;
580 s->dropable = s1->dropable;
582 // DivX handling (doesn't work)
583 s->divx_packed = s1->divx_packed;
585 if (s1->bitstream_buffer) {
586 if (s1->bitstream_buffer_size +
587 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
588 av_fast_malloc(&s->bitstream_buffer,
589 &s->allocated_bitstream_buffer_size,
590 s1->allocated_bitstream_buffer_size);
591 s->bitstream_buffer_size = s1->bitstream_buffer_size;
592 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
593 s1->bitstream_buffer_size);
594 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
595 FF_INPUT_BUFFER_PADDING_SIZE);
598 // MPEG2/interlacing info
599 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
600 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
602 if (!s1->first_field) {
603 s->last_pict_type = s1->pict_type;
604 if (s1->current_picture_ptr)
605 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
607 if (s1->pict_type != AV_PICTURE_TYPE_B) {
608 s->last_non_b_pict_type = s1->pict_type;
616 * Set the given MpegEncContext to common defaults
617 * (same for encoding and decoding).
618 * The changed fields will not depend upon the
619 * prior state of the MpegEncContext.
621 void MPV_common_defaults(MpegEncContext *s)
623 s->y_dc_scale_table =
624 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
625 s->chroma_qscale_table = ff_default_chroma_qscale_table;
626 s->progressive_frame = 1;
627 s->progressive_sequence = 1;
628 s->picture_structure = PICT_FRAME;
630 s->coded_picture_number = 0;
631 s->picture_number = 0;
632 s->input_picture_number = 0;
634 s->picture_in_gop_number = 0;
639 s->picture_range_start = 0;
640 s->picture_range_end = MAX_PICTURE_COUNT;
642 s->slice_context_count = 1;
646 * Set the given MpegEncContext to defaults for decoding.
647 * the changed fields will not depend upon
648 * the prior state of the MpegEncContext.
650 void MPV_decode_defaults(MpegEncContext *s)
652 MPV_common_defaults(s);
656 * init common structure for both encoder and decoder.
657 * this assumes that some variables like width/height are already set
659 av_cold int MPV_common_init(MpegEncContext *s)
661 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
662 int nb_slices = (HAVE_THREADS &&
663 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
664 s->avctx->thread_count : 1;
666 if (s->encoding && s->avctx->slices)
667 nb_slices = s->avctx->slices;
669 if (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
670 s->mb_height = (s->height + 31) / 32 * 2;
671 else if (s->codec_id != CODEC_ID_H264)
672 s->mb_height = (s->height + 15) / 16;
674 if (s->avctx->pix_fmt == PIX_FMT_NONE) {
675 av_log(s->avctx, AV_LOG_ERROR,
676 "decoding to PIX_FMT_NONE is not supported.\n");
680 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
683 max_slices = FFMIN(MAX_THREADS, s->mb_height);
685 max_slices = MAX_THREADS;
686 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
687 " reducing to %d\n", nb_slices, max_slices);
688 nb_slices = max_slices;
691 if ((s->width || s->height) &&
692 av_image_check_size(s->width, s->height, 0, s->avctx))
695 ff_dct_common_init(s);
697 s->flags = s->avctx->flags;
698 s->flags2 = s->avctx->flags2;
700 s->mb_width = (s->width + 15) / 16;
701 s->mb_stride = s->mb_width + 1;
702 s->b8_stride = s->mb_width * 2 + 1;
703 s->b4_stride = s->mb_width * 4 + 1;
704 mb_array_size = s->mb_height * s->mb_stride;
705 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
707 /* set chroma shifts */
708 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
711 /* set default edge pos, will be overriden in decode_header if needed */
712 s->h_edge_pos = s->mb_width * 16;
713 s->v_edge_pos = s->mb_height * 16;
715 s->mb_num = s->mb_width * s->mb_height;
720 s->block_wrap[3] = s->b8_stride;
722 s->block_wrap[5] = s->mb_stride;
724 y_size = s->b8_stride * (2 * s->mb_height + 1);
725 c_size = s->mb_stride * (s->mb_height + 1);
726 yc_size = y_size + 2 * c_size;
728 /* convert fourcc to upper case */
729 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
730 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
732 s->avctx->coded_frame = (AVFrame*)&s->current_picture;
734 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
735 for (y = 0; y < s->mb_height; y++)
736 for (x = 0; x < s->mb_width; x++)
737 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
739 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
742 /* Allocate MV tables */
743 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
744 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
745 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
746 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
747 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
748 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
749 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
750 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
751 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
752 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
753 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
754 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
756 if(s->msmpeg4_version){
757 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
759 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
761 /* Allocate MB type table */
762 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
764 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
766 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
767 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix , 64*32 * sizeof(int), fail)
768 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
769 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
770 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
771 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
772 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
773 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
775 if(s->avctx->noise_reduction){
776 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
780 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
781 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
782 s->picture_count * sizeof(Picture), fail);
783 for (i = 0; i < s->picture_count; i++) {
784 avcodec_get_frame_defaults((AVFrame *) &s->picture[i]);
787 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
789 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
790 /* interlaced direct mode decoding tables */
791 for (i = 0; i < 2; i++) {
793 for (j = 0; j < 2; j++) {
794 for (k = 0; k < 2; k++) {
795 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
796 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
798 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
799 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
800 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
802 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
805 if (s->out_format == FMT_H263) {
807 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
808 s->coded_block = s->coded_block_base + s->b8_stride + 1;
810 /* cbp, ac_pred, pred_dir */
811 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
812 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
815 if (s->h263_pred || s->h263_plus || !s->encoding) {
817 // MN: we need these for error resilience of intra-frames
818 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
819 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
820 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
821 s->dc_val[2] = s->dc_val[1] + c_size;
822 for (i = 0; i < yc_size; i++)
823 s->dc_val_base[i] = 1024;
826 /* which mb is a intra block */
827 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
828 memset(s->mbintra_table, 1, mb_array_size);
830 /* init macroblock skip table */
831 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
832 // Note the + 1 is for a quicker mpeg4 slice_end detection
834 s->parse_context.state = -1;
836 s->context_initialized = 1;
837 s->thread_context[0] = s;
839 // if (s->width && s->height) {
841 for (i = 1; i < nb_slices; i++) {
842 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
843 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
846 for (i = 0; i < nb_slices; i++) {
847 if (init_duplicate_context(s->thread_context[i], s) < 0)
849 s->thread_context[i]->start_mb_y =
850 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
851 s->thread_context[i]->end_mb_y =
852 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
855 if (init_duplicate_context(s, s) < 0)
858 s->end_mb_y = s->mb_height;
860 s->slice_context_count = nb_slices;
869 /* init common structure for both encoder and decoder */
870 void MPV_common_end(MpegEncContext *s)
874 if (s->slice_context_count > 1) {
875 for (i = 0; i < s->slice_context_count; i++) {
876 free_duplicate_context(s->thread_context[i]);
878 for (i = 1; i < s->slice_context_count; i++) {
879 av_freep(&s->thread_context[i]);
881 s->slice_context_count = 1;
882 } else free_duplicate_context(s);
884 av_freep(&s->parse_context.buffer);
885 s->parse_context.buffer_size = 0;
887 av_freep(&s->mb_type);
888 av_freep(&s->p_mv_table_base);
889 av_freep(&s->b_forw_mv_table_base);
890 av_freep(&s->b_back_mv_table_base);
891 av_freep(&s->b_bidir_forw_mv_table_base);
892 av_freep(&s->b_bidir_back_mv_table_base);
893 av_freep(&s->b_direct_mv_table_base);
894 s->p_mv_table = NULL;
895 s->b_forw_mv_table = NULL;
896 s->b_back_mv_table = NULL;
897 s->b_bidir_forw_mv_table = NULL;
898 s->b_bidir_back_mv_table = NULL;
899 s->b_direct_mv_table = NULL;
900 for (i = 0; i < 2; i++) {
901 for (j = 0; j < 2; j++) {
902 for (k = 0; k < 2; k++) {
903 av_freep(&s->b_field_mv_table_base[i][j][k]);
904 s->b_field_mv_table[i][j][k] = NULL;
906 av_freep(&s->b_field_select_table[i][j]);
907 av_freep(&s->p_field_mv_table_base[i][j]);
908 s->p_field_mv_table[i][j] = NULL;
910 av_freep(&s->p_field_select_table[i]);
913 av_freep(&s->dc_val_base);
914 av_freep(&s->coded_block_base);
915 av_freep(&s->mbintra_table);
916 av_freep(&s->cbp_table);
917 av_freep(&s->pred_dir_table);
919 av_freep(&s->mbskip_table);
920 av_freep(&s->bitstream_buffer);
921 s->allocated_bitstream_buffer_size = 0;
923 av_freep(&s->avctx->stats_out);
924 av_freep(&s->ac_stats);
925 av_freep(&s->error_status_table);
926 av_freep(&s->mb_index2xy);
927 av_freep(&s->lambda_table);
928 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
929 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
930 s->q_chroma_intra_matrix= NULL;
931 s->q_chroma_intra_matrix16= NULL;
932 av_freep(&s->q_intra_matrix);
933 av_freep(&s->q_inter_matrix);
934 av_freep(&s->q_intra_matrix16);
935 av_freep(&s->q_inter_matrix16);
936 av_freep(&s->input_picture);
937 av_freep(&s->reordered_input_picture);
938 av_freep(&s->dct_offset);
940 if (s->picture && !s->avctx->internal->is_copy) {
941 for (i = 0; i < s->picture_count; i++) {
942 free_picture(s, &s->picture[i]);
945 av_freep(&s->picture);
946 s->context_initialized = 0;
947 s->last_picture_ptr =
948 s->next_picture_ptr =
949 s->current_picture_ptr = NULL;
950 s->linesize = s->uvlinesize = 0;
952 for (i = 0; i < 3; i++)
953 av_freep(&s->visualization_buffer[i]);
955 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
956 avcodec_default_free_buffers(s->avctx);
959 void init_rl(RLTable *rl,
960 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
962 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
963 uint8_t index_run[MAX_RUN + 1];
964 int last, run, level, start, end, i;
966 /* If table is static, we can quit if rl->max_level[0] is not NULL */
967 if (static_store && rl->max_level[0])
970 /* compute max_level[], max_run[] and index_run[] */
971 for (last = 0; last < 2; last++) {
980 memset(max_level, 0, MAX_RUN + 1);
981 memset(max_run, 0, MAX_LEVEL + 1);
982 memset(index_run, rl->n, MAX_RUN + 1);
983 for (i = start; i < end; i++) {
984 run = rl->table_run[i];
985 level = rl->table_level[i];
986 if (index_run[run] == rl->n)
988 if (level > max_level[run])
989 max_level[run] = level;
990 if (run > max_run[level])
991 max_run[level] = run;
994 rl->max_level[last] = static_store[last];
996 rl->max_level[last] = av_malloc(MAX_RUN + 1);
997 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
999 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1001 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1002 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1004 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1006 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1007 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1011 void init_vlc_rl(RLTable *rl)
1015 for (q = 0; q < 32; q++) {
1017 int qadd = (q - 1) | 1;
1023 for (i = 0; i < rl->vlc.table_size; i++) {
1024 int code = rl->vlc.table[i][0];
1025 int len = rl->vlc.table[i][1];
1028 if (len == 0) { // illegal code
1031 } else if (len < 0) { // more bits needed
1035 if (code == rl->n) { // esc
1039 run = rl->table_run[code] + 1;
1040 level = rl->table_level[code] * qmul + qadd;
1041 if (code >= rl->last) run += 192;
1044 rl->rl_vlc[q][i].len = len;
1045 rl->rl_vlc[q][i].level = level;
1046 rl->rl_vlc[q][i].run = run;
1051 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1055 /* release non reference frames */
1056 for (i = 0; i < s->picture_count; i++) {
1057 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1058 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1059 (remove_current || &s->picture[i] != s->current_picture_ptr)
1060 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1061 free_frame_buffer(s, &s->picture[i]);
1066 int ff_find_unused_picture(MpegEncContext *s, int shared)
1071 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1072 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1076 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1077 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
1080 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1081 if (s->picture[i].f.data[0] == NULL)
1086 av_log(s->avctx, AV_LOG_FATAL,
1087 "Internal error, picture buffer overflow\n");
1088 /* We could return -1, but the codec would crash trying to draw into a
1089 * non-existing frame anyway. This is safer than waiting for a random crash.
1090 * Also the return of this is never useful, an encoder must only allocate
1091 * as much as allowed in the specification. This has no relationship to how
1092 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1093 * enough for such valid streams).
1094 * Plus, a decoder has to check stream validity and remove frames if too
1095 * many reference frames are around. Waiting for "OOM" is not correct at
1096 * all. Similarly, missing reference frames have to be replaced by
1097 * interpolated/MC frames, anything else is a bug in the codec ...
1103 static void update_noise_reduction(MpegEncContext *s)
1107 for (intra = 0; intra < 2; intra++) {
1108 if (s->dct_count[intra] > (1 << 16)) {
1109 for (i = 0; i < 64; i++) {
1110 s->dct_error_sum[intra][i] >>= 1;
1112 s->dct_count[intra] >>= 1;
1115 for (i = 0; i < 64; i++) {
1116 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1117 s->dct_count[intra] +
1118 s->dct_error_sum[intra][i] / 2) /
1119 (s->dct_error_sum[intra][i] + 1);
1125 * generic function for encode/decode called after coding/decoding
1126 * the header and before a frame is coded/decoded.
1128 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1134 assert(s->last_picture_ptr == NULL || s->out_format != FMT_H264 ||
1135 s->codec_id == CODEC_ID_SVQ3);
1137 /* mark & release old frames */
1138 if (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3) {
1139 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1140 s->last_picture_ptr != s->next_picture_ptr &&
1141 s->last_picture_ptr->f.data[0]) {
1142 if (s->last_picture_ptr->owner2 == s)
1143 free_frame_buffer(s, s->last_picture_ptr);
1146 /* release forgotten pictures */
1147 /* if (mpeg124/h263) */
1149 for (i = 0; i < s->picture_count; i++) {
1150 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1151 &s->picture[i] != s->last_picture_ptr &&
1152 &s->picture[i] != s->next_picture_ptr &&
1153 s->picture[i].f.reference) {
1154 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1155 av_log(avctx, AV_LOG_ERROR,
1156 "releasing zombie picture\n");
1157 free_frame_buffer(s, &s->picture[i]);
1164 ff_release_unused_pictures(s, 1);
1166 if (s->current_picture_ptr &&
1167 s->current_picture_ptr->f.data[0] == NULL) {
1168 // we already have a unused image
1169 // (maybe it was set before reading the header)
1170 pic = s->current_picture_ptr;
1172 i = ff_find_unused_picture(s, 0);
1175 pic = &s->picture[i];
1178 pic->f.reference = 0;
1180 if (s->codec_id == CODEC_ID_H264)
1181 pic->f.reference = s->picture_structure;
1182 else if (s->pict_type != AV_PICTURE_TYPE_B)
1183 pic->f.reference = 3;
1186 pic->f.coded_picture_number = s->coded_picture_number++;
1188 if (ff_alloc_picture(s, pic, 0) < 0)
1191 s->current_picture_ptr = pic;
1192 // FIXME use only the vars from current_pic
1193 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1194 if (s->codec_id == CODEC_ID_MPEG1VIDEO ||
1195 s->codec_id == CODEC_ID_MPEG2VIDEO) {
1196 if (s->picture_structure != PICT_FRAME)
1197 s->current_picture_ptr->f.top_field_first =
1198 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1200 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1201 !s->progressive_sequence;
1202 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1205 s->current_picture_ptr->f.pict_type = s->pict_type;
1206 // if (s->flags && CODEC_FLAG_QSCALE)
1207 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1208 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1210 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1212 if (s->pict_type != AV_PICTURE_TYPE_B) {
1213 s->last_picture_ptr = s->next_picture_ptr;
1215 s->next_picture_ptr = s->current_picture_ptr;
1217 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1218 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1219 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1220 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1221 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1222 s->pict_type, s->dropable); */
1224 if (s->codec_id != CODEC_ID_H264) {
1225 if ((s->last_picture_ptr == NULL ||
1226 s->last_picture_ptr->f.data[0] == NULL) &&
1227 (s->pict_type != AV_PICTURE_TYPE_I ||
1228 s->picture_structure != PICT_FRAME)) {
1229 if (s->pict_type != AV_PICTURE_TYPE_I)
1230 av_log(avctx, AV_LOG_ERROR,
1231 "warning: first frame is no keyframe\n");
1232 else if (s->picture_structure != PICT_FRAME)
1233 av_log(avctx, AV_LOG_INFO,
1234 "allocate dummy last picture for field based first keyframe\n");
1236 /* Allocate a dummy frame */
1237 i = ff_find_unused_picture(s, 0);
1240 s->last_picture_ptr= &s->picture[i];
1241 s->last_picture_ptr->f.key_frame = 0;
1242 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1245 if(s->codec_id == CODEC_ID_FLV1 || s->codec_id == CODEC_ID_H263){
1246 for(i=0; i<avctx->height; i++)
1247 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1250 ff_thread_report_progress((AVFrame *) s->last_picture_ptr,
1252 ff_thread_report_progress((AVFrame *) s->last_picture_ptr,
1255 if ((s->next_picture_ptr == NULL ||
1256 s->next_picture_ptr->f.data[0] == NULL) &&
1257 s->pict_type == AV_PICTURE_TYPE_B) {
1258 /* Allocate a dummy frame */
1259 i = ff_find_unused_picture(s, 0);
1262 s->next_picture_ptr= &s->picture[i];
1263 s->next_picture_ptr->f.key_frame = 0;
1264 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1266 ff_thread_report_progress((AVFrame *) s->next_picture_ptr,
1268 ff_thread_report_progress((AVFrame *) s->next_picture_ptr,
1273 if (s->last_picture_ptr)
1274 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1275 if (s->next_picture_ptr)
1276 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1278 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1279 (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3)) {
1280 if (s->next_picture_ptr)
1281 s->next_picture_ptr->owner2 = s;
1282 if (s->last_picture_ptr)
1283 s->last_picture_ptr->owner2 = s;
1286 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1287 s->last_picture_ptr->f.data[0]));
1289 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1291 for (i = 0; i < 4; i++) {
1292 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1293 s->current_picture.f.data[i] +=
1294 s->current_picture.f.linesize[i];
1296 s->current_picture.f.linesize[i] *= 2;
1297 s->last_picture.f.linesize[i] *= 2;
1298 s->next_picture.f.linesize[i] *= 2;
1302 s->err_recognition = avctx->err_recognition;
1304 /* set dequantizer, we can't do it during init as
1305 * it might change for mpeg4 and we can't do it in the header
1306 * decode as init is not called for mpeg4 there yet */
1307 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1308 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1309 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1310 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1311 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1312 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1314 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1315 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1318 if (s->dct_error_sum) {
1319 assert(s->avctx->noise_reduction && s->encoding);
1320 update_noise_reduction(s);
1323 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1324 return ff_xvmc_field_start(s, avctx);
1329 /* generic function for encode/decode called after a
1330 * frame has been coded/decoded. */
1331 void MPV_frame_end(MpegEncContext *s)
1334 /* redraw edges for the frame if decoding didn't complete */
1335 // just to make sure that all data is rendered.
1336 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1337 ff_xvmc_field_end(s);
1338 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1339 !s->avctx->hwaccel &&
1340 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1341 s->unrestricted_mv &&
1342 s->current_picture.f.reference &&
1344 !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1345 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1346 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1347 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1348 s->h_edge_pos, s->v_edge_pos,
1349 EDGE_WIDTH, EDGE_WIDTH,
1350 EDGE_TOP | EDGE_BOTTOM);
1351 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1352 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1353 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1354 EDGE_TOP | EDGE_BOTTOM);
1355 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1356 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1357 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1358 EDGE_TOP | EDGE_BOTTOM);
1363 s->last_pict_type = s->pict_type;
1364 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1365 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1366 s->last_non_b_pict_type = s->pict_type;
1369 /* copy back current_picture variables */
1370 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1371 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1372 s->picture[i] = s->current_picture;
1376 assert(i < MAX_PICTURE_COUNT);
1380 /* release non-reference frames */
1381 for (i = 0; i < s->picture_count; i++) {
1382 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1383 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1384 free_frame_buffer(s, &s->picture[i]);
1388 // clear copies, to avoid confusion
1390 memset(&s->last_picture, 0, sizeof(Picture));
1391 memset(&s->next_picture, 0, sizeof(Picture));
1392 memset(&s->current_picture, 0, sizeof(Picture));
1394 s->avctx->coded_frame = (AVFrame *) s->current_picture_ptr;
1396 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1397 ff_thread_report_progress((AVFrame *) s->current_picture_ptr,
1398 s->mb_height - 1, 0);
1403 * Draw a line from (ex, ey) -> (sx, sy).
1404 * @param w width of the image
1405 * @param h height of the image
1406 * @param stride stride/linesize of the image
1407 * @param color color of the arrow
1409 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1410 int w, int h, int stride, int color)
1414 sx = av_clip(sx, 0, w - 1);
1415 sy = av_clip(sy, 0, h - 1);
1416 ex = av_clip(ex, 0, w - 1);
1417 ey = av_clip(ey, 0, h - 1);
1419 buf[sy * stride + sx] += color;
1421 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1423 FFSWAP(int, sx, ex);
1424 FFSWAP(int, sy, ey);
1426 buf += sx + sy * stride;
1428 f = ((ey - sy) << 16) / ex;
1429 for(x= 0; x <= ex; x++){
1431 fr = (x * f) & 0xFFFF;
1432 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1433 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1437 FFSWAP(int, sx, ex);
1438 FFSWAP(int, sy, ey);
1440 buf += sx + sy * stride;
1443 f = ((ex - sx) << 16) / ey;
1446 for(y= 0; y <= ey; y++){
1448 fr = (y*f) & 0xFFFF;
1449 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1450 buf[y * stride + x + 1] += (color * fr ) >> 16;
1456 * Draw an arrow from (ex, ey) -> (sx, sy).
1457 * @param w width of the image
1458 * @param h height of the image
1459 * @param stride stride/linesize of the image
1460 * @param color color of the arrow
1462 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1463 int ey, int w, int h, int stride, int color)
1467 sx = av_clip(sx, -100, w + 100);
1468 sy = av_clip(sy, -100, h + 100);
1469 ex = av_clip(ex, -100, w + 100);
1470 ey = av_clip(ey, -100, h + 100);
1475 if (dx * dx + dy * dy > 3 * 3) {
1478 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1480 // FIXME subpixel accuracy
1481 rx = ROUNDED_DIV(rx * 3 << 4, length);
1482 ry = ROUNDED_DIV(ry * 3 << 4, length);
1484 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1485 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1487 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1491 * Print debugging info for the given picture.
1493 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1495 if (s->avctx->hwaccel || !pict || !pict->mb_type)
1498 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1501 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1502 av_get_picture_type_char(pict->pict_type));
1503 for (y = 0; y < s->mb_height; y++) {
1504 for (x = 0; x < s->mb_width; x++) {
1505 if (s->avctx->debug & FF_DEBUG_SKIP) {
1506 int count = s->mbskip_table[x + y * s->mb_stride];
1509 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1511 if (s->avctx->debug & FF_DEBUG_QP) {
1512 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1513 pict->qscale_table[x + y * s->mb_stride]);
1515 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1516 int mb_type = pict->mb_type[x + y * s->mb_stride];
1517 // Type & MV direction
1518 if (IS_PCM(mb_type))
1519 av_log(s->avctx, AV_LOG_DEBUG, "P");
1520 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1521 av_log(s->avctx, AV_LOG_DEBUG, "A");
1522 else if (IS_INTRA4x4(mb_type))
1523 av_log(s->avctx, AV_LOG_DEBUG, "i");
1524 else if (IS_INTRA16x16(mb_type))
1525 av_log(s->avctx, AV_LOG_DEBUG, "I");
1526 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1527 av_log(s->avctx, AV_LOG_DEBUG, "d");
1528 else if (IS_DIRECT(mb_type))
1529 av_log(s->avctx, AV_LOG_DEBUG, "D");
1530 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1531 av_log(s->avctx, AV_LOG_DEBUG, "g");
1532 else if (IS_GMC(mb_type))
1533 av_log(s->avctx, AV_LOG_DEBUG, "G");
1534 else if (IS_SKIP(mb_type))
1535 av_log(s->avctx, AV_LOG_DEBUG, "S");
1536 else if (!USES_LIST(mb_type, 1))
1537 av_log(s->avctx, AV_LOG_DEBUG, ">");
1538 else if (!USES_LIST(mb_type, 0))
1539 av_log(s->avctx, AV_LOG_DEBUG, "<");
1541 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1542 av_log(s->avctx, AV_LOG_DEBUG, "X");
1546 if (IS_8X8(mb_type))
1547 av_log(s->avctx, AV_LOG_DEBUG, "+");
1548 else if (IS_16X8(mb_type))
1549 av_log(s->avctx, AV_LOG_DEBUG, "-");
1550 else if (IS_8X16(mb_type))
1551 av_log(s->avctx, AV_LOG_DEBUG, "|");
1552 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1553 av_log(s->avctx, AV_LOG_DEBUG, " ");
1555 av_log(s->avctx, AV_LOG_DEBUG, "?");
1558 if (IS_INTERLACED(mb_type))
1559 av_log(s->avctx, AV_LOG_DEBUG, "=");
1561 av_log(s->avctx, AV_LOG_DEBUG, " ");
1563 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1565 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1569 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1570 (s->avctx->debug_mv)) {
1571 const int shift = 1 + s->quarter_sample;
1575 int h_chroma_shift, v_chroma_shift, block_height;
1576 const int width = s->avctx->width;
1577 const int height = s->avctx->height;
1578 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1579 const int mv_stride = (s->mb_width << mv_sample_log2) +
1580 (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1581 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1583 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1584 &h_chroma_shift, &v_chroma_shift);
1585 for (i = 0; i < 3; i++) {
1586 size_t size= (i == 0) ? pict->linesize[i] * height:
1587 pict->linesize[i] * height >> v_chroma_shift;
1588 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1589 memcpy(s->visualization_buffer[i], pict->data[i], size);
1590 pict->data[i] = s->visualization_buffer[i];
1592 pict->type = FF_BUFFER_TYPE_COPY;
1594 ptr = pict->data[0];
1595 block_height = 16 >> v_chroma_shift;
1597 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1599 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1600 const int mb_index = mb_x + mb_y * s->mb_stride;
1601 if ((s->avctx->debug_mv) && pict->motion_val) {
1603 for (type = 0; type < 3; type++) {
1607 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1608 (pict->pict_type!= AV_PICTURE_TYPE_P))
1613 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1614 (pict->pict_type!= AV_PICTURE_TYPE_B))
1619 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1620 (pict->pict_type!= AV_PICTURE_TYPE_B))
1625 if (!USES_LIST(pict->mb_type[mb_index], direction))
1628 if (IS_8X8(pict->mb_type[mb_index])) {
1630 for (i = 0; i < 4; i++) {
1631 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1632 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1633 int xy = (mb_x * 2 + (i & 1) +
1634 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1635 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1636 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1637 draw_arrow(ptr, sx, sy, mx, my, width,
1638 height, s->linesize, 100);
1640 } else if (IS_16X8(pict->mb_type[mb_index])) {
1642 for (i = 0; i < 2; i++) {
1643 int sx = mb_x * 16 + 8;
1644 int sy = mb_y * 16 + 4 + 8 * i;
1645 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1646 int mx = (pict->motion_val[direction][xy][0] >> shift);
1647 int my = (pict->motion_val[direction][xy][1] >> shift);
1649 if (IS_INTERLACED(pict->mb_type[mb_index]))
1652 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1653 height, s->linesize, 100);
1655 } else if (IS_8X16(pict->mb_type[mb_index])) {
1657 for (i = 0; i < 2; i++) {
1658 int sx = mb_x * 16 + 4 + 8 * i;
1659 int sy = mb_y * 16 + 8;
1660 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1661 int mx = pict->motion_val[direction][xy][0] >> shift;
1662 int my = pict->motion_val[direction][xy][1] >> shift;
1664 if (IS_INTERLACED(pict->mb_type[mb_index]))
1667 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1668 height, s->linesize, 100);
1671 int sx= mb_x * 16 + 8;
1672 int sy= mb_y * 16 + 8;
1673 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1674 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1675 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1676 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1680 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1681 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1682 0x0101010101010101ULL;
1684 for (y = 0; y < block_height; y++) {
1685 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1686 (block_height * mb_y + y) *
1687 pict->linesize[1]) = c;
1688 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1689 (block_height * mb_y + y) *
1690 pict->linesize[2]) = c;
1693 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1695 int mb_type = pict->mb_type[mb_index];
1698 #define COLOR(theta, r) \
1699 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1700 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1704 if (IS_PCM(mb_type)) {
1706 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1707 IS_INTRA16x16(mb_type)) {
1709 } else if (IS_INTRA4x4(mb_type)) {
1711 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1713 } else if (IS_DIRECT(mb_type)) {
1715 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1717 } else if (IS_GMC(mb_type)) {
1719 } else if (IS_SKIP(mb_type)) {
1721 } else if (!USES_LIST(mb_type, 1)) {
1723 } else if (!USES_LIST(mb_type, 0)) {
1726 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1730 u *= 0x0101010101010101ULL;
1731 v *= 0x0101010101010101ULL;
1732 for (y = 0; y < block_height; y++) {
1733 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1734 (block_height * mb_y + y) * pict->linesize[1]) = u;
1735 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1736 (block_height * mb_y + y) * pict->linesize[2]) = v;
1740 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1741 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1742 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1743 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1744 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1746 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1747 for (y = 0; y < 16; y++)
1748 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1749 pict->linesize[0]] ^= 0x80;
1751 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1752 int dm = 1 << (mv_sample_log2 - 2);
1753 for (i = 0; i < 4; i++) {
1754 int sx = mb_x * 16 + 8 * (i & 1);
1755 int sy = mb_y * 16 + 8 * (i >> 1);
1756 int xy = (mb_x * 2 + (i & 1) +
1757 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1759 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1760 if (mv[0] != mv[dm] ||
1761 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1762 for (y = 0; y < 8; y++)
1763 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1764 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1765 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1766 pict->linesize[0]) ^= 0x8080808080808080ULL;
1770 if (IS_INTERLACED(mb_type) &&
1771 s->codec_id == CODEC_ID_H264) {
1775 s->mbskip_table[mb_index] = 0;
1781 static inline int hpel_motion_lowres(MpegEncContext *s,
1782 uint8_t *dest, uint8_t *src,
1783 int field_based, int field_select,
1784 int src_x, int src_y,
1785 int width, int height, int stride,
1786 int h_edge_pos, int v_edge_pos,
1787 int w, int h, h264_chroma_mc_func *pix_op,
1788 int motion_x, int motion_y)
1790 const int lowres = s->avctx->lowres;
1791 const int op_index = FFMIN(lowres, 2);
1792 const int s_mask = (2 << lowres) - 1;
1796 if (s->quarter_sample) {
1801 sx = motion_x & s_mask;
1802 sy = motion_y & s_mask;
1803 src_x += motion_x >> lowres + 1;
1804 src_y += motion_y >> lowres + 1;
1806 src += src_y * stride + src_x;
1808 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1809 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1810 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1811 (h + 1) << field_based, src_x,
1812 src_y << field_based,
1815 src = s->edge_emu_buffer;
1819 sx = (sx << 2) >> lowres;
1820 sy = (sy << 2) >> lowres;
1823 pix_op[op_index](dest, src, stride, h, sx, sy);
1827 /* apply one mpeg motion vector to the three components */
1828 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1835 uint8_t **ref_picture,
1836 h264_chroma_mc_func *pix_op,
1837 int motion_x, int motion_y,
1840 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1841 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1843 const int lowres = s->avctx->lowres;
1844 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
1845 const int block_s = 8>>lowres;
1846 const int s_mask = (2 << lowres) - 1;
1847 const int h_edge_pos = s->h_edge_pos >> lowres;
1848 const int v_edge_pos = s->v_edge_pos >> lowres;
1849 linesize = s->current_picture.f.linesize[0] << field_based;
1850 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1852 // FIXME obviously not perfect but qpel will not work in lowres anyway
1853 if (s->quarter_sample) {
1859 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1862 sx = motion_x & s_mask;
1863 sy = motion_y & s_mask;
1864 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1865 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1867 if (s->out_format == FMT_H263) {
1868 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1869 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1870 uvsrc_x = src_x >> 1;
1871 uvsrc_y = src_y >> 1;
1872 } else if (s->out_format == FMT_H261) {
1873 // even chroma mv's are full pel in H261
1876 uvsx = (2 * mx) & s_mask;
1877 uvsy = (2 * my) & s_mask;
1878 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1879 uvsrc_y = mb_y * block_s + (my >> lowres);
1881 if(s->chroma_y_shift){
1886 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1887 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1889 if(s->chroma_x_shift){
1893 uvsy = motion_y & s_mask;
1895 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1898 uvsx = motion_x & s_mask;
1899 uvsy = motion_y & s_mask;
1906 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1907 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1908 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1910 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
1911 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1912 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
1913 s->linesize, 17, 17 + field_based,
1914 src_x, src_y << field_based, h_edge_pos,
1916 ptr_y = s->edge_emu_buffer;
1917 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1918 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
1919 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
1921 uvsrc_x, uvsrc_y << field_based,
1922 h_edge_pos >> 1, v_edge_pos >> 1);
1923 s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
1925 uvsrc_x, uvsrc_y << field_based,
1926 h_edge_pos >> 1, v_edge_pos >> 1);
1928 ptr_cr = uvbuf + 16;
1932 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1934 dest_y += s->linesize;
1935 dest_cb += s->uvlinesize;
1936 dest_cr += s->uvlinesize;
1940 ptr_y += s->linesize;
1941 ptr_cb += s->uvlinesize;
1942 ptr_cr += s->uvlinesize;
1945 sx = (sx << 2) >> lowres;
1946 sy = (sy << 2) >> lowres;
1947 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1949 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1950 uvsx = (uvsx << 2) >> lowres;
1951 uvsy = (uvsy << 2) >> lowres;
1952 if (h >> s->chroma_y_shift) {
1953 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1954 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1957 // FIXME h261 lowres loop filter
1960 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1961 uint8_t *dest_cb, uint8_t *dest_cr,
1962 uint8_t **ref_picture,
1963 h264_chroma_mc_func * pix_op,
1966 const int lowres = s->avctx->lowres;
1967 const int op_index = FFMIN(lowres, 2);
1968 const int block_s = 8 >> lowres;
1969 const int s_mask = (2 << lowres) - 1;
1970 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1971 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1972 int emu = 0, src_x, src_y, offset, sx, sy;
1975 if (s->quarter_sample) {
1980 /* In case of 8X8, we construct a single chroma motion vector
1981 with a special rounding */
1982 mx = ff_h263_round_chroma(mx);
1983 my = ff_h263_round_chroma(my);
1987 src_x = s->mb_x * block_s + (mx >> lowres + 1);
1988 src_y = s->mb_y * block_s + (my >> lowres + 1);
1990 offset = src_y * s->uvlinesize + src_x;
1991 ptr = ref_picture[1] + offset;
1992 if (s->flags & CODEC_FLAG_EMU_EDGE) {
1993 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1994 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1995 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
1996 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1997 ptr = s->edge_emu_buffer;
2001 sx = (sx << 2) >> lowres;
2002 sy = (sy << 2) >> lowres;
2003 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2005 ptr = ref_picture[2] + offset;
2007 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2008 src_x, src_y, h_edge_pos, v_edge_pos);
2009 ptr = s->edge_emu_buffer;
2011 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2015 * motion compensation of a single macroblock
2017 * @param dest_y luma destination pointer
2018 * @param dest_cb chroma cb/u destination pointer
2019 * @param dest_cr chroma cr/v destination pointer
2020 * @param dir direction (0->forward, 1->backward)
2021 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2022 * @param pix_op halfpel motion compensation function (average or put normally)
2023 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2025 static inline void MPV_motion_lowres(MpegEncContext *s,
2026 uint8_t *dest_y, uint8_t *dest_cb,
2028 int dir, uint8_t **ref_picture,
2029 h264_chroma_mc_func *pix_op)
2033 const int lowres = s->avctx->lowres;
2034 const int block_s = 8 >>lowres;
2039 switch (s->mv_type) {
2041 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2043 ref_picture, pix_op,
2044 s->mv[dir][0][0], s->mv[dir][0][1],
2050 for (i = 0; i < 4; i++) {
2051 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2052 s->linesize) * block_s,
2053 ref_picture[0], 0, 0,
2054 (2 * mb_x + (i & 1)) * block_s,
2055 (2 * mb_y + (i >> 1)) * block_s,
2056 s->width, s->height, s->linesize,
2057 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2058 block_s, block_s, pix_op,
2059 s->mv[dir][i][0], s->mv[dir][i][1]);
2061 mx += s->mv[dir][i][0];
2062 my += s->mv[dir][i][1];
2065 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2066 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2070 if (s->picture_structure == PICT_FRAME) {
2072 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2073 1, 0, s->field_select[dir][0],
2074 ref_picture, pix_op,
2075 s->mv[dir][0][0], s->mv[dir][0][1],
2078 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2079 1, 1, s->field_select[dir][1],
2080 ref_picture, pix_op,
2081 s->mv[dir][1][0], s->mv[dir][1][1],
2084 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2085 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2086 ref_picture = s->current_picture_ptr->f.data;
2089 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2090 0, 0, s->field_select[dir][0],
2091 ref_picture, pix_op,
2093 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2097 for (i = 0; i < 2; i++) {
2098 uint8_t **ref2picture;
2100 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2101 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2102 ref2picture = ref_picture;
2104 ref2picture = s->current_picture_ptr->f.data;
2107 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2108 0, 0, s->field_select[dir][i],
2109 ref2picture, pix_op,
2110 s->mv[dir][i][0], s->mv[dir][i][1] +
2111 2 * block_s * i, block_s, mb_y >> 1);
2113 dest_y += 2 * block_s * s->linesize;
2114 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2115 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2119 if (s->picture_structure == PICT_FRAME) {
2120 for (i = 0; i < 2; i++) {
2122 for (j = 0; j < 2; j++) {
2123 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2125 ref_picture, pix_op,
2126 s->mv[dir][2 * i + j][0],
2127 s->mv[dir][2 * i + j][1],
2130 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2133 for (i = 0; i < 2; i++) {
2134 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2135 0, 0, s->picture_structure != i + 1,
2136 ref_picture, pix_op,
2137 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2138 2 * block_s, mb_y >> 1);
2140 // after put we make avg of the same block
2141 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2143 // opposite parity is always in the same
2144 // frame if this is second field
2145 if (!s->first_field) {
2146 ref_picture = s->current_picture_ptr->f.data;
2157 * find the lowest MB row referenced in the MVs
2159 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2161 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2162 int my, off, i, mvs;
2164 if (s->picture_structure != PICT_FRAME) goto unhandled;
2166 switch (s->mv_type) {
2180 for (i = 0; i < mvs; i++) {
2181 my = s->mv[dir][i][1]<<qpel_shift;
2182 my_max = FFMAX(my_max, my);
2183 my_min = FFMIN(my_min, my);
2186 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2188 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2190 return s->mb_height-1;
2193 /* put block[] to dest[] */
2194 static inline void put_dct(MpegEncContext *s,
2195 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2197 s->dct_unquantize_intra(s, block, i, qscale);
2198 s->dsp.idct_put (dest, line_size, block);
2201 /* add block[] to dest[] */
2202 static inline void add_dct(MpegEncContext *s,
2203 DCTELEM *block, int i, uint8_t *dest, int line_size)
2205 if (s->block_last_index[i] >= 0) {
2206 s->dsp.idct_add (dest, line_size, block);
2210 static inline void add_dequant_dct(MpegEncContext *s,
2211 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2213 if (s->block_last_index[i] >= 0) {
2214 s->dct_unquantize_inter(s, block, i, qscale);
2216 s->dsp.idct_add (dest, line_size, block);
2221 * Clean dc, ac, coded_block for the current non-intra MB.
2223 void ff_clean_intra_table_entries(MpegEncContext *s)
2225 int wrap = s->b8_stride;
2226 int xy = s->block_index[0];
2229 s->dc_val[0][xy + 1 ] =
2230 s->dc_val[0][xy + wrap] =
2231 s->dc_val[0][xy + 1 + wrap] = 1024;
2233 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2234 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2235 if (s->msmpeg4_version>=3) {
2236 s->coded_block[xy ] =
2237 s->coded_block[xy + 1 ] =
2238 s->coded_block[xy + wrap] =
2239 s->coded_block[xy + 1 + wrap] = 0;
2242 wrap = s->mb_stride;
2243 xy = s->mb_x + s->mb_y * wrap;
2245 s->dc_val[2][xy] = 1024;
2247 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2248 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2250 s->mbintra_table[xy]= 0;
2253 /* generic function called after a macroblock has been parsed by the
2254 decoder or after it has been encoded by the encoder.
2256 Important variables used:
2257 s->mb_intra : true if intra macroblock
2258 s->mv_dir : motion vector direction
2259 s->mv_type : motion vector type
2260 s->mv : motion vector
2261 s->interlaced_dct : true if interlaced dct used (mpeg2)
2263 static av_always_inline
2264 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2265 int lowres_flag, int is_mpeg12)
2267 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2268 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2269 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2273 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2274 /* save DCT coefficients */
2276 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2277 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2279 for(j=0; j<64; j++){
2280 *dct++ = block[i][s->dsp.idct_permutation[j]];
2281 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2283 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2287 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2289 /* update DC predictors for P macroblocks */
2291 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2292 if(s->mbintra_table[mb_xy])
2293 ff_clean_intra_table_entries(s);
2297 s->last_dc[2] = 128 << s->intra_dc_precision;
2300 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2301 s->mbintra_table[mb_xy]=1;
2303 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
2304 uint8_t *dest_y, *dest_cb, *dest_cr;
2305 int dct_linesize, dct_offset;
2306 op_pixels_func (*op_pix)[4];
2307 qpel_mc_func (*op_qpix)[16];
2308 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2309 const int uvlinesize = s->current_picture.f.linesize[1];
2310 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2311 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2313 /* avoid copy if macroblock skipped in last frame too */
2314 /* skip only during decoding as we might trash the buffers during encoding a bit */
2316 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2318 if (s->mb_skipped) {
2320 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2322 } else if(!s->current_picture.f.reference) {
2325 *mbskip_ptr = 0; /* not skipped */
2329 dct_linesize = linesize << s->interlaced_dct;
2330 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2334 dest_cb= s->dest[1];
2335 dest_cr= s->dest[2];
2337 dest_y = s->b_scratchpad;
2338 dest_cb= s->b_scratchpad+16*linesize;
2339 dest_cr= s->b_scratchpad+32*linesize;
2343 /* motion handling */
2344 /* decoding or more than one mb_type (MC was already done otherwise) */
2347 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2348 if (s->mv_dir & MV_DIR_FORWARD) {
2349 ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2351 if (s->mv_dir & MV_DIR_BACKWARD) {
2352 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2357 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2359 if (s->mv_dir & MV_DIR_FORWARD) {
2360 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2361 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2363 if (s->mv_dir & MV_DIR_BACKWARD) {
2364 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2367 op_qpix= s->me.qpel_put;
2368 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2369 op_pix = s->dsp.put_pixels_tab;
2371 op_pix = s->dsp.put_no_rnd_pixels_tab;
2373 if (s->mv_dir & MV_DIR_FORWARD) {
2374 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2375 op_pix = s->dsp.avg_pixels_tab;
2376 op_qpix= s->me.qpel_avg;
2378 if (s->mv_dir & MV_DIR_BACKWARD) {
2379 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2384 /* skip dequant / idct if we are really late ;) */
2385 if(s->avctx->skip_idct){
2386 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2387 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2388 || s->avctx->skip_idct >= AVDISCARD_ALL)
2392 /* add dct residue */
2393 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2394 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2395 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2396 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2397 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2398 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2400 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2401 if (s->chroma_y_shift){
2402 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2403 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2407 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2408 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2409 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2410 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2413 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2414 add_dct(s, block[0], 0, dest_y , dct_linesize);
2415 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2416 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2417 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2419 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2420 if(s->chroma_y_shift){//Chroma420
2421 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2422 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2425 dct_linesize = uvlinesize << s->interlaced_dct;
2426 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2428 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2429 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2430 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2431 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2432 if(!s->chroma_x_shift){//Chroma444
2433 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2434 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2435 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2436 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2441 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2442 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2445 /* dct only in intra block */
2446 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2447 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2448 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2449 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2450 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2452 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2453 if(s->chroma_y_shift){
2454 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2455 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2459 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2460 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2461 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2462 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2466 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2467 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2468 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2469 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2471 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2472 if(s->chroma_y_shift){
2473 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2474 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2477 dct_linesize = uvlinesize << s->interlaced_dct;
2478 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2480 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2481 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2482 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2483 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2484 if(!s->chroma_x_shift){//Chroma444
2485 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2486 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2487 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2488 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2496 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2497 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2498 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2503 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2505 if(s->out_format == FMT_MPEG1) {
2506 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2507 else MPV_decode_mb_internal(s, block, 0, 1);
2510 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2511 else MPV_decode_mb_internal(s, block, 0, 0);
2515 * @param h is the normal height, this will be reduced automatically if needed for the last row
2517 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2518 const int field_pic= s->picture_structure != PICT_FRAME;
2524 if (!s->avctx->hwaccel
2525 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2526 && s->unrestricted_mv
2527 && s->current_picture.f.reference
2529 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2530 int sides = 0, edge_h;
2531 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2532 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2533 if (y==0) sides |= EDGE_TOP;
2534 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2536 edge_h= FFMIN(h, s->v_edge_pos - y);
2538 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2539 s->linesize, s->h_edge_pos, edge_h,
2540 EDGE_WIDTH, EDGE_WIDTH, sides);
2541 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2542 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2543 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2544 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2545 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2546 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2549 h= FFMIN(h, s->avctx->height - y);
2551 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2553 if (s->avctx->draw_horiz_band) {
2555 int offset[AV_NUM_DATA_POINTERS];
2558 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2559 src= (AVFrame*)s->current_picture_ptr;
2560 else if(s->last_picture_ptr)
2561 src= (AVFrame*)s->last_picture_ptr;
2565 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2566 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2569 offset[0]= y * s->linesize;
2571 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2572 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2578 s->avctx->draw_horiz_band(s->avctx, src, offset,
2579 y, s->picture_structure, h);
2583 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2584 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2585 const int uvlinesize = s->current_picture.f.linesize[1];
2586 const int mb_size= 4 - s->avctx->lowres;
2588 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2589 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2590 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2591 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2592 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2593 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;
2594 //block_index is not used by mpeg2, so it is not affected by chroma_format
2596 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2597 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2598 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2600 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2602 if(s->picture_structure==PICT_FRAME){
2603 s->dest[0] += s->mb_y * linesize << mb_size;
2604 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2605 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2607 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2608 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2609 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2610 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2615 void ff_mpeg_flush(AVCodecContext *avctx){
2617 MpegEncContext *s = avctx->priv_data;
2619 if(s==NULL || s->picture==NULL)
2622 for(i=0; i<s->picture_count; i++){
2623 if (s->picture[i].f.data[0] &&
2624 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2625 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2626 free_frame_buffer(s, &s->picture[i]);
2628 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2630 s->mb_x= s->mb_y= 0;
2633 s->parse_context.state= -1;
2634 s->parse_context.frame_start_found= 0;
2635 s->parse_context.overread= 0;
2636 s->parse_context.overread_index= 0;
2637 s->parse_context.index= 0;
2638 s->parse_context.last_index= 0;
2639 s->bitstream_buffer_size=0;
2643 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2644 DCTELEM *block, int n, int qscale)
2646 int i, level, nCoeffs;
2647 const uint16_t *quant_matrix;
2649 nCoeffs= s->block_last_index[n];
2652 block[0] = block[0] * s->y_dc_scale;
2654 block[0] = block[0] * s->c_dc_scale;
2655 /* XXX: only mpeg1 */
2656 quant_matrix = s->intra_matrix;
2657 for(i=1;i<=nCoeffs;i++) {
2658 int j= s->intra_scantable.permutated[i];
2663 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2664 level = (level - 1) | 1;
2667 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2668 level = (level - 1) | 1;
2675 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2676 DCTELEM *block, int n, int qscale)
2678 int i, level, nCoeffs;
2679 const uint16_t *quant_matrix;
2681 nCoeffs= s->block_last_index[n];
2683 quant_matrix = s->inter_matrix;
2684 for(i=0; i<=nCoeffs; i++) {
2685 int j= s->intra_scantable.permutated[i];
2690 level = (((level << 1) + 1) * qscale *
2691 ((int) (quant_matrix[j]))) >> 4;
2692 level = (level - 1) | 1;
2695 level = (((level << 1) + 1) * qscale *
2696 ((int) (quant_matrix[j]))) >> 4;
2697 level = (level - 1) | 1;
2704 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2705 DCTELEM *block, int n, int qscale)
2707 int i, level, nCoeffs;
2708 const uint16_t *quant_matrix;
2710 if(s->alternate_scan) nCoeffs= 63;
2711 else nCoeffs= s->block_last_index[n];
2714 block[0] = block[0] * s->y_dc_scale;
2716 block[0] = block[0] * s->c_dc_scale;
2717 quant_matrix = s->intra_matrix;
2718 for(i=1;i<=nCoeffs;i++) {
2719 int j= s->intra_scantable.permutated[i];
2724 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2727 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2734 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2735 DCTELEM *block, int n, int qscale)
2737 int i, level, nCoeffs;
2738 const uint16_t *quant_matrix;
2741 if(s->alternate_scan) nCoeffs= 63;
2742 else nCoeffs= s->block_last_index[n];
2745 block[0] = block[0] * s->y_dc_scale;
2747 block[0] = block[0] * s->c_dc_scale;
2748 quant_matrix = s->intra_matrix;
2749 for(i=1;i<=nCoeffs;i++) {
2750 int j= s->intra_scantable.permutated[i];
2755 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2758 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2767 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2768 DCTELEM *block, int n, int qscale)
2770 int i, level, nCoeffs;
2771 const uint16_t *quant_matrix;
2774 if(s->alternate_scan) nCoeffs= 63;
2775 else nCoeffs= s->block_last_index[n];
2777 quant_matrix = s->inter_matrix;
2778 for(i=0; i<=nCoeffs; i++) {
2779 int j= s->intra_scantable.permutated[i];
2784 level = (((level << 1) + 1) * qscale *
2785 ((int) (quant_matrix[j]))) >> 4;
2788 level = (((level << 1) + 1) * qscale *
2789 ((int) (quant_matrix[j]))) >> 4;
2798 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2799 DCTELEM *block, int n, int qscale)
2801 int i, level, qmul, qadd;
2804 assert(s->block_last_index[n]>=0);
2810 block[0] = block[0] * s->y_dc_scale;
2812 block[0] = block[0] * s->c_dc_scale;
2813 qadd = (qscale - 1) | 1;
2820 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2822 for(i=1; i<=nCoeffs; i++) {
2826 level = level * qmul - qadd;
2828 level = level * qmul + qadd;
2835 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2836 DCTELEM *block, int n, int qscale)
2838 int i, level, qmul, qadd;
2841 assert(s->block_last_index[n]>=0);
2843 qadd = (qscale - 1) | 1;
2846 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2848 for(i=0; i<=nCoeffs; i++) {
2852 level = level * qmul - qadd;
2854 level = level * qmul + qadd;
2862 * set qscale and update qscale dependent variables.
2864 void ff_set_qscale(MpegEncContext * s, int qscale)
2868 else if (qscale > 31)
2872 s->chroma_qscale= s->chroma_qscale_table[qscale];
2874 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2875 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2878 void MPV_report_decode_progress(MpegEncContext *s)
2880 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2881 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);