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;
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->bitstream_buffer = NULL;
544 s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
546 if (s1->context_initialized){
547 s->picture_range_start += MAX_PICTURE_COUNT;
548 s->picture_range_end += MAX_PICTURE_COUNT;
553 s->avctx->coded_height = s1->avctx->coded_height;
554 s->avctx->coded_width = s1->avctx->coded_width;
555 s->avctx->width = s1->avctx->width;
556 s->avctx->height = s1->avctx->height;
558 s->coded_picture_number = s1->coded_picture_number;
559 s->picture_number = s1->picture_number;
560 s->input_picture_number = s1->input_picture_number;
562 memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
563 memcpy(&s->last_picture, &s1->last_picture,
564 (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
566 s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
567 s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
568 s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
570 // Error/bug resilience
571 s->next_p_frame_damaged = s1->next_p_frame_damaged;
572 s->workaround_bugs = s1->workaround_bugs;
573 s->padding_bug_score = s1->padding_bug_score;
576 memcpy(&s->time_increment_bits, &s1->time_increment_bits,
577 (char *) &s1->shape - (char *) &s1->time_increment_bits);
580 s->max_b_frames = s1->max_b_frames;
581 s->low_delay = s1->low_delay;
582 s->dropable = s1->dropable;
584 // DivX handling (doesn't work)
585 s->divx_packed = s1->divx_packed;
587 if (s1->bitstream_buffer) {
588 if (s1->bitstream_buffer_size +
589 FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
590 av_fast_malloc(&s->bitstream_buffer,
591 &s->allocated_bitstream_buffer_size,
592 s1->allocated_bitstream_buffer_size);
593 s->bitstream_buffer_size = s1->bitstream_buffer_size;
594 memcpy(s->bitstream_buffer, s1->bitstream_buffer,
595 s1->bitstream_buffer_size);
596 memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
597 FF_INPUT_BUFFER_PADDING_SIZE);
600 // MPEG2/interlacing info
601 memcpy(&s->progressive_sequence, &s1->progressive_sequence,
602 (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
604 if (!s1->first_field) {
605 s->last_pict_type = s1->pict_type;
606 if (s1->current_picture_ptr)
607 s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
609 if (s1->pict_type != AV_PICTURE_TYPE_B) {
610 s->last_non_b_pict_type = s1->pict_type;
618 * Set the given MpegEncContext to common defaults
619 * (same for encoding and decoding).
620 * The changed fields will not depend upon the
621 * prior state of the MpegEncContext.
623 void MPV_common_defaults(MpegEncContext *s)
625 s->y_dc_scale_table =
626 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
627 s->chroma_qscale_table = ff_default_chroma_qscale_table;
628 s->progressive_frame = 1;
629 s->progressive_sequence = 1;
630 s->picture_structure = PICT_FRAME;
632 s->coded_picture_number = 0;
633 s->picture_number = 0;
634 s->input_picture_number = 0;
636 s->picture_in_gop_number = 0;
641 s->picture_range_start = 0;
642 s->picture_range_end = MAX_PICTURE_COUNT;
644 s->slice_context_count = 1;
648 * Set the given MpegEncContext to defaults for decoding.
649 * the changed fields will not depend upon
650 * the prior state of the MpegEncContext.
652 void MPV_decode_defaults(MpegEncContext *s)
654 MPV_common_defaults(s);
658 * init common structure for both encoder and decoder.
659 * this assumes that some variables like width/height are already set
661 av_cold int MPV_common_init(MpegEncContext *s)
663 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
664 int nb_slices = (HAVE_THREADS &&
665 s->avctx->active_thread_type & FF_THREAD_SLICE) ?
666 s->avctx->thread_count : 1;
668 if (s->encoding && s->avctx->slices)
669 nb_slices = s->avctx->slices;
671 if (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
672 s->mb_height = (s->height + 31) / 32 * 2;
673 else if (s->codec_id != CODEC_ID_H264)
674 s->mb_height = (s->height + 15) / 16;
676 if (s->avctx->pix_fmt == PIX_FMT_NONE) {
677 av_log(s->avctx, AV_LOG_ERROR,
678 "decoding to PIX_FMT_NONE is not supported.\n");
682 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
685 max_slices = FFMIN(MAX_THREADS, s->mb_height);
687 max_slices = MAX_THREADS;
688 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
689 " reducing to %d\n", nb_slices, max_slices);
690 nb_slices = max_slices;
693 if ((s->width || s->height) &&
694 av_image_check_size(s->width, s->height, 0, s->avctx))
697 ff_dct_common_init(s);
699 s->flags = s->avctx->flags;
700 s->flags2 = s->avctx->flags2;
702 s->mb_width = (s->width + 15) / 16;
703 s->mb_stride = s->mb_width + 1;
704 s->b8_stride = s->mb_width * 2 + 1;
705 s->b4_stride = s->mb_width * 4 + 1;
706 mb_array_size = s->mb_height * s->mb_stride;
707 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
709 /* set chroma shifts */
710 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
713 /* set default edge pos, will be overriden in decode_header if needed */
714 s->h_edge_pos = s->mb_width * 16;
715 s->v_edge_pos = s->mb_height * 16;
717 s->mb_num = s->mb_width * s->mb_height;
722 s->block_wrap[3] = s->b8_stride;
724 s->block_wrap[5] = s->mb_stride;
726 y_size = s->b8_stride * (2 * s->mb_height + 1);
727 c_size = s->mb_stride * (s->mb_height + 1);
728 yc_size = y_size + 2 * c_size;
730 /* convert fourcc to upper case */
731 s->codec_tag = avpriv_toupper4(s->avctx->codec_tag);
732 s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
734 s->avctx->coded_frame = (AVFrame*)&s->current_picture;
736 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
737 for (y = 0; y < s->mb_height; y++)
738 for (x = 0; x < s->mb_width; x++)
739 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
741 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
744 /* Allocate MV tables */
745 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
746 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
747 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
748 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
749 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
750 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
751 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
752 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
753 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
754 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
755 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
756 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
758 if(s->msmpeg4_version){
759 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
761 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
763 /* Allocate MB type table */
764 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
766 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
768 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
769 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix , 64*32 * sizeof(int), fail)
770 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
771 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
772 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
773 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16 , 64*32*2 * sizeof(uint16_t), fail)
774 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
775 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
777 if(s->avctx->noise_reduction){
778 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
782 s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
783 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
784 s->picture_count * sizeof(Picture), fail);
785 for (i = 0; i < s->picture_count; i++) {
786 avcodec_get_frame_defaults((AVFrame *) &s->picture[i]);
789 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
791 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
792 /* interlaced direct mode decoding tables */
793 for (i = 0; i < 2; i++) {
795 for (j = 0; j < 2; j++) {
796 for (k = 0; k < 2; k++) {
797 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
798 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
800 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
801 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
802 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
804 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
807 if (s->out_format == FMT_H263) {
809 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
810 s->coded_block = s->coded_block_base + s->b8_stride + 1;
812 /* cbp, ac_pred, pred_dir */
813 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail);
814 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
817 if (s->h263_pred || s->h263_plus || !s->encoding) {
819 // MN: we need these for error resilience of intra-frames
820 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
821 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
822 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
823 s->dc_val[2] = s->dc_val[1] + c_size;
824 for (i = 0; i < yc_size; i++)
825 s->dc_val_base[i] = 1024;
828 /* which mb is a intra block */
829 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
830 memset(s->mbintra_table, 1, mb_array_size);
832 /* init macroblock skip table */
833 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
834 // Note the + 1 is for a quicker mpeg4 slice_end detection
836 s->parse_context.state = -1;
838 s->context_initialized = 1;
839 s->thread_context[0] = s;
841 // if (s->width && s->height) {
843 for (i = 1; i < nb_slices; i++) {
844 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
845 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
848 for (i = 0; i < nb_slices; i++) {
849 if (init_duplicate_context(s->thread_context[i], s) < 0)
851 s->thread_context[i]->start_mb_y =
852 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
853 s->thread_context[i]->end_mb_y =
854 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
857 if (init_duplicate_context(s, s) < 0)
860 s->end_mb_y = s->mb_height;
862 s->slice_context_count = nb_slices;
871 /* init common structure for both encoder and decoder */
872 void MPV_common_end(MpegEncContext *s)
876 if (s->slice_context_count > 1) {
877 for (i = 0; i < s->slice_context_count; i++) {
878 free_duplicate_context(s->thread_context[i]);
880 for (i = 1; i < s->slice_context_count; i++) {
881 av_freep(&s->thread_context[i]);
883 s->slice_context_count = 1;
884 } else free_duplicate_context(s);
886 av_freep(&s->parse_context.buffer);
887 s->parse_context.buffer_size = 0;
889 av_freep(&s->mb_type);
890 av_freep(&s->p_mv_table_base);
891 av_freep(&s->b_forw_mv_table_base);
892 av_freep(&s->b_back_mv_table_base);
893 av_freep(&s->b_bidir_forw_mv_table_base);
894 av_freep(&s->b_bidir_back_mv_table_base);
895 av_freep(&s->b_direct_mv_table_base);
896 s->p_mv_table = NULL;
897 s->b_forw_mv_table = NULL;
898 s->b_back_mv_table = NULL;
899 s->b_bidir_forw_mv_table = NULL;
900 s->b_bidir_back_mv_table = NULL;
901 s->b_direct_mv_table = NULL;
902 for (i = 0; i < 2; i++) {
903 for (j = 0; j < 2; j++) {
904 for (k = 0; k < 2; k++) {
905 av_freep(&s->b_field_mv_table_base[i][j][k]);
906 s->b_field_mv_table[i][j][k] = NULL;
908 av_freep(&s->b_field_select_table[i][j]);
909 av_freep(&s->p_field_mv_table_base[i][j]);
910 s->p_field_mv_table[i][j] = NULL;
912 av_freep(&s->p_field_select_table[i]);
915 av_freep(&s->dc_val_base);
916 av_freep(&s->coded_block_base);
917 av_freep(&s->mbintra_table);
918 av_freep(&s->cbp_table);
919 av_freep(&s->pred_dir_table);
921 av_freep(&s->mbskip_table);
922 av_freep(&s->bitstream_buffer);
923 s->allocated_bitstream_buffer_size = 0;
925 av_freep(&s->avctx->stats_out);
926 av_freep(&s->ac_stats);
927 av_freep(&s->error_status_table);
928 av_freep(&s->mb_index2xy);
929 av_freep(&s->lambda_table);
930 if(s->q_chroma_intra_matrix != s->q_intra_matrix ) av_freep(&s->q_chroma_intra_matrix);
931 if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
932 s->q_chroma_intra_matrix= NULL;
933 s->q_chroma_intra_matrix16= NULL;
934 av_freep(&s->q_intra_matrix);
935 av_freep(&s->q_inter_matrix);
936 av_freep(&s->q_intra_matrix16);
937 av_freep(&s->q_inter_matrix16);
938 av_freep(&s->input_picture);
939 av_freep(&s->reordered_input_picture);
940 av_freep(&s->dct_offset);
942 if (s->picture && !s->avctx->internal->is_copy) {
943 for (i = 0; i < s->picture_count; i++) {
944 free_picture(s, &s->picture[i]);
947 av_freep(&s->picture);
948 s->context_initialized = 0;
949 s->last_picture_ptr =
950 s->next_picture_ptr =
951 s->current_picture_ptr = NULL;
952 s->linesize = s->uvlinesize = 0;
954 for (i = 0; i < 3; i++)
955 av_freep(&s->visualization_buffer[i]);
957 if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
958 avcodec_default_free_buffers(s->avctx);
961 void init_rl(RLTable *rl,
962 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
964 int8_t max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
965 uint8_t index_run[MAX_RUN + 1];
966 int last, run, level, start, end, i;
968 /* If table is static, we can quit if rl->max_level[0] is not NULL */
969 if (static_store && rl->max_level[0])
972 /* compute max_level[], max_run[] and index_run[] */
973 for (last = 0; last < 2; last++) {
982 memset(max_level, 0, MAX_RUN + 1);
983 memset(max_run, 0, MAX_LEVEL + 1);
984 memset(index_run, rl->n, MAX_RUN + 1);
985 for (i = start; i < end; i++) {
986 run = rl->table_run[i];
987 level = rl->table_level[i];
988 if (index_run[run] == rl->n)
990 if (level > max_level[run])
991 max_level[run] = level;
992 if (run > max_run[level])
993 max_run[level] = run;
996 rl->max_level[last] = static_store[last];
998 rl->max_level[last] = av_malloc(MAX_RUN + 1);
999 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1001 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
1003 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1004 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1006 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1008 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1009 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1013 void init_vlc_rl(RLTable *rl)
1017 for (q = 0; q < 32; q++) {
1019 int qadd = (q - 1) | 1;
1025 for (i = 0; i < rl->vlc.table_size; i++) {
1026 int code = rl->vlc.table[i][0];
1027 int len = rl->vlc.table[i][1];
1030 if (len == 0) { // illegal code
1033 } else if (len < 0) { // more bits needed
1037 if (code == rl->n) { // esc
1041 run = rl->table_run[code] + 1;
1042 level = rl->table_level[code] * qmul + qadd;
1043 if (code >= rl->last) run += 192;
1046 rl->rl_vlc[q][i].len = len;
1047 rl->rl_vlc[q][i].level = level;
1048 rl->rl_vlc[q][i].run = run;
1053 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1057 /* release non reference frames */
1058 for (i = 0; i < s->picture_count; i++) {
1059 if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1060 (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1061 (remove_current || &s->picture[i] != s->current_picture_ptr)
1062 /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1063 free_frame_buffer(s, &s->picture[i]);
1068 int ff_find_unused_picture(MpegEncContext *s, int shared)
1073 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1074 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1078 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1079 if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type != 0)
1082 for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1083 if (s->picture[i].f.data[0] == NULL)
1088 av_log(s->avctx, AV_LOG_FATAL,
1089 "Internal error, picture buffer overflow\n");
1090 /* We could return -1, but the codec would crash trying to draw into a
1091 * non-existing frame anyway. This is safer than waiting for a random crash.
1092 * Also the return of this is never useful, an encoder must only allocate
1093 * as much as allowed in the specification. This has no relationship to how
1094 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1095 * enough for such valid streams).
1096 * Plus, a decoder has to check stream validity and remove frames if too
1097 * many reference frames are around. Waiting for "OOM" is not correct at
1098 * all. Similarly, missing reference frames have to be replaced by
1099 * interpolated/MC frames, anything else is a bug in the codec ...
1105 static void update_noise_reduction(MpegEncContext *s)
1109 for (intra = 0; intra < 2; intra++) {
1110 if (s->dct_count[intra] > (1 << 16)) {
1111 for (i = 0; i < 64; i++) {
1112 s->dct_error_sum[intra][i] >>= 1;
1114 s->dct_count[intra] >>= 1;
1117 for (i = 0; i < 64; i++) {
1118 s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1119 s->dct_count[intra] +
1120 s->dct_error_sum[intra][i] / 2) /
1121 (s->dct_error_sum[intra][i] + 1);
1127 * generic function for encode/decode called after coding/decoding
1128 * the header and before a frame is coded/decoded.
1130 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1136 assert(s->last_picture_ptr == NULL || s->out_format != FMT_H264 ||
1137 s->codec_id == CODEC_ID_SVQ3);
1139 /* mark & release old frames */
1140 if (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3) {
1141 if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1142 s->last_picture_ptr != s->next_picture_ptr &&
1143 s->last_picture_ptr->f.data[0]) {
1144 if (s->last_picture_ptr->owner2 == s)
1145 free_frame_buffer(s, s->last_picture_ptr);
1148 /* release forgotten pictures */
1149 /* if (mpeg124/h263) */
1151 for (i = 0; i < s->picture_count; i++) {
1152 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1153 &s->picture[i] != s->last_picture_ptr &&
1154 &s->picture[i] != s->next_picture_ptr &&
1155 s->picture[i].f.reference) {
1156 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1157 av_log(avctx, AV_LOG_ERROR,
1158 "releasing zombie picture\n");
1159 free_frame_buffer(s, &s->picture[i]);
1166 ff_release_unused_pictures(s, 1);
1168 if (s->current_picture_ptr &&
1169 s->current_picture_ptr->f.data[0] == NULL) {
1170 // we already have a unused image
1171 // (maybe it was set before reading the header)
1172 pic = s->current_picture_ptr;
1174 i = ff_find_unused_picture(s, 0);
1177 pic = &s->picture[i];
1180 pic->f.reference = 0;
1182 if (s->codec_id == CODEC_ID_H264)
1183 pic->f.reference = s->picture_structure;
1184 else if (s->pict_type != AV_PICTURE_TYPE_B)
1185 pic->f.reference = 3;
1188 pic->f.coded_picture_number = s->coded_picture_number++;
1190 if (ff_alloc_picture(s, pic, 0) < 0)
1193 s->current_picture_ptr = pic;
1194 // FIXME use only the vars from current_pic
1195 s->current_picture_ptr->f.top_field_first = s->top_field_first;
1196 if (s->codec_id == CODEC_ID_MPEG1VIDEO ||
1197 s->codec_id == CODEC_ID_MPEG2VIDEO) {
1198 if (s->picture_structure != PICT_FRAME)
1199 s->current_picture_ptr->f.top_field_first =
1200 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1202 s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1203 !s->progressive_sequence;
1204 s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1207 s->current_picture_ptr->f.pict_type = s->pict_type;
1208 // if (s->flags && CODEC_FLAG_QSCALE)
1209 // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1210 s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1212 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1214 if (s->pict_type != AV_PICTURE_TYPE_B) {
1215 s->last_picture_ptr = s->next_picture_ptr;
1217 s->next_picture_ptr = s->current_picture_ptr;
1219 /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1220 s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1221 s->last_picture_ptr ? s->last_picture_ptr->f.data[0] : NULL,
1222 s->next_picture_ptr ? s->next_picture_ptr->f.data[0] : NULL,
1223 s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1224 s->pict_type, s->dropable); */
1226 if (s->codec_id != CODEC_ID_H264) {
1227 if ((s->last_picture_ptr == NULL ||
1228 s->last_picture_ptr->f.data[0] == NULL) &&
1229 (s->pict_type != AV_PICTURE_TYPE_I ||
1230 s->picture_structure != PICT_FRAME)) {
1231 if (s->pict_type != AV_PICTURE_TYPE_I)
1232 av_log(avctx, AV_LOG_ERROR,
1233 "warning: first frame is no keyframe\n");
1234 else if (s->picture_structure != PICT_FRAME)
1235 av_log(avctx, AV_LOG_INFO,
1236 "allocate dummy last picture for field based first keyframe\n");
1238 /* Allocate a dummy frame */
1239 i = ff_find_unused_picture(s, 0);
1242 s->last_picture_ptr= &s->picture[i];
1243 s->last_picture_ptr->f.key_frame = 0;
1244 if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1247 if(s->codec_id == CODEC_ID_FLV1 || s->codec_id == CODEC_ID_H263){
1248 for(i=0; i<avctx->height; i++)
1249 memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1252 ff_thread_report_progress((AVFrame *) s->last_picture_ptr,
1254 ff_thread_report_progress((AVFrame *) s->last_picture_ptr,
1257 if ((s->next_picture_ptr == NULL ||
1258 s->next_picture_ptr->f.data[0] == NULL) &&
1259 s->pict_type == AV_PICTURE_TYPE_B) {
1260 /* Allocate a dummy frame */
1261 i = ff_find_unused_picture(s, 0);
1264 s->next_picture_ptr= &s->picture[i];
1265 s->next_picture_ptr->f.key_frame = 0;
1266 if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1268 ff_thread_report_progress((AVFrame *) s->next_picture_ptr,
1270 ff_thread_report_progress((AVFrame *) s->next_picture_ptr,
1275 if (s->last_picture_ptr)
1276 ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1277 if (s->next_picture_ptr)
1278 ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1280 if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1281 (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3)) {
1282 if (s->next_picture_ptr)
1283 s->next_picture_ptr->owner2 = s;
1284 if (s->last_picture_ptr)
1285 s->last_picture_ptr->owner2 = s;
1288 assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1289 s->last_picture_ptr->f.data[0]));
1291 if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1293 for (i = 0; i < 4; i++) {
1294 if (s->picture_structure == PICT_BOTTOM_FIELD) {
1295 s->current_picture.f.data[i] +=
1296 s->current_picture.f.linesize[i];
1298 s->current_picture.f.linesize[i] *= 2;
1299 s->last_picture.f.linesize[i] *= 2;
1300 s->next_picture.f.linesize[i] *= 2;
1304 s->err_recognition = avctx->err_recognition;
1306 /* set dequantizer, we can't do it during init as
1307 * it might change for mpeg4 and we can't do it in the header
1308 * decode as init is not called for mpeg4 there yet */
1309 if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1310 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1311 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1312 } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1313 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1314 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1316 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1317 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1320 if (s->dct_error_sum) {
1321 assert(s->avctx->noise_reduction && s->encoding);
1322 update_noise_reduction(s);
1325 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1326 return ff_xvmc_field_start(s, avctx);
1331 /* generic function for encode/decode called after a
1332 * frame has been coded/decoded. */
1333 void MPV_frame_end(MpegEncContext *s)
1336 /* redraw edges for the frame if decoding didn't complete */
1337 // just to make sure that all data is rendered.
1338 if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1339 ff_xvmc_field_end(s);
1340 } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1341 !s->avctx->hwaccel &&
1342 !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1343 s->unrestricted_mv &&
1344 s->current_picture.f.reference &&
1346 !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1347 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1348 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1349 s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1350 s->h_edge_pos, s->v_edge_pos,
1351 EDGE_WIDTH, EDGE_WIDTH,
1352 EDGE_TOP | EDGE_BOTTOM);
1353 s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1354 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1355 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1356 EDGE_TOP | EDGE_BOTTOM);
1357 s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1358 s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1359 EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1360 EDGE_TOP | EDGE_BOTTOM);
1365 s->last_pict_type = s->pict_type;
1366 s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1367 if (s->pict_type!= AV_PICTURE_TYPE_B) {
1368 s->last_non_b_pict_type = s->pict_type;
1371 /* copy back current_picture variables */
1372 for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1373 if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1374 s->picture[i] = s->current_picture;
1378 assert(i < MAX_PICTURE_COUNT);
1382 /* release non-reference frames */
1383 for (i = 0; i < s->picture_count; i++) {
1384 if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1385 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1386 free_frame_buffer(s, &s->picture[i]);
1390 // clear copies, to avoid confusion
1392 memset(&s->last_picture, 0, sizeof(Picture));
1393 memset(&s->next_picture, 0, sizeof(Picture));
1394 memset(&s->current_picture, 0, sizeof(Picture));
1396 s->avctx->coded_frame = (AVFrame *) s->current_picture_ptr;
1398 if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1399 ff_thread_report_progress((AVFrame *) s->current_picture_ptr,
1400 s->mb_height - 1, 0);
1405 * Draw a line from (ex, ey) -> (sx, sy).
1406 * @param w width of the image
1407 * @param h height of the image
1408 * @param stride stride/linesize of the image
1409 * @param color color of the arrow
1411 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1412 int w, int h, int stride, int color)
1416 sx = av_clip(sx, 0, w - 1);
1417 sy = av_clip(sy, 0, h - 1);
1418 ex = av_clip(ex, 0, w - 1);
1419 ey = av_clip(ey, 0, h - 1);
1421 buf[sy * stride + sx] += color;
1423 if (FFABS(ex - sx) > FFABS(ey - sy)) {
1425 FFSWAP(int, sx, ex);
1426 FFSWAP(int, sy, ey);
1428 buf += sx + sy * stride;
1430 f = ((ey - sy) << 16) / ex;
1431 for(x= 0; x <= ex; x++){
1433 fr = (x * f) & 0xFFFF;
1434 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1435 buf[(y + 1) * stride + x] += (color * fr ) >> 16;
1439 FFSWAP(int, sx, ex);
1440 FFSWAP(int, sy, ey);
1442 buf += sx + sy * stride;
1445 f = ((ex - sx) << 16) / ey;
1448 for(y= 0; y <= ey; y++){
1450 fr = (y*f) & 0xFFFF;
1451 buf[y * stride + x] += (color * (0x10000 - fr)) >> 16;
1452 buf[y * stride + x + 1] += (color * fr ) >> 16;
1458 * Draw an arrow from (ex, ey) -> (sx, sy).
1459 * @param w width of the image
1460 * @param h height of the image
1461 * @param stride stride/linesize of the image
1462 * @param color color of the arrow
1464 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1465 int ey, int w, int h, int stride, int color)
1469 sx = av_clip(sx, -100, w + 100);
1470 sy = av_clip(sy, -100, h + 100);
1471 ex = av_clip(ex, -100, w + 100);
1472 ey = av_clip(ey, -100, h + 100);
1477 if (dx * dx + dy * dy > 3 * 3) {
1480 int length = ff_sqrt((rx * rx + ry * ry) << 8);
1482 // FIXME subpixel accuracy
1483 rx = ROUNDED_DIV(rx * 3 << 4, length);
1484 ry = ROUNDED_DIV(ry * 3 << 4, length);
1486 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1487 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1489 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1493 * Print debugging info for the given picture.
1495 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1497 if (s->avctx->hwaccel || !pict || !pict->mb_type)
1500 if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1503 av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1504 av_get_picture_type_char(pict->pict_type));
1505 for (y = 0; y < s->mb_height; y++) {
1506 for (x = 0; x < s->mb_width; x++) {
1507 if (s->avctx->debug & FF_DEBUG_SKIP) {
1508 int count = s->mbskip_table[x + y * s->mb_stride];
1511 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1513 if (s->avctx->debug & FF_DEBUG_QP) {
1514 av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1515 pict->qscale_table[x + y * s->mb_stride]);
1517 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1518 int mb_type = pict->mb_type[x + y * s->mb_stride];
1519 // Type & MV direction
1520 if (IS_PCM(mb_type))
1521 av_log(s->avctx, AV_LOG_DEBUG, "P");
1522 else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1523 av_log(s->avctx, AV_LOG_DEBUG, "A");
1524 else if (IS_INTRA4x4(mb_type))
1525 av_log(s->avctx, AV_LOG_DEBUG, "i");
1526 else if (IS_INTRA16x16(mb_type))
1527 av_log(s->avctx, AV_LOG_DEBUG, "I");
1528 else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1529 av_log(s->avctx, AV_LOG_DEBUG, "d");
1530 else if (IS_DIRECT(mb_type))
1531 av_log(s->avctx, AV_LOG_DEBUG, "D");
1532 else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1533 av_log(s->avctx, AV_LOG_DEBUG, "g");
1534 else if (IS_GMC(mb_type))
1535 av_log(s->avctx, AV_LOG_DEBUG, "G");
1536 else if (IS_SKIP(mb_type))
1537 av_log(s->avctx, AV_LOG_DEBUG, "S");
1538 else if (!USES_LIST(mb_type, 1))
1539 av_log(s->avctx, AV_LOG_DEBUG, ">");
1540 else if (!USES_LIST(mb_type, 0))
1541 av_log(s->avctx, AV_LOG_DEBUG, "<");
1543 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1544 av_log(s->avctx, AV_LOG_DEBUG, "X");
1548 if (IS_8X8(mb_type))
1549 av_log(s->avctx, AV_LOG_DEBUG, "+");
1550 else if (IS_16X8(mb_type))
1551 av_log(s->avctx, AV_LOG_DEBUG, "-");
1552 else if (IS_8X16(mb_type))
1553 av_log(s->avctx, AV_LOG_DEBUG, "|");
1554 else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1555 av_log(s->avctx, AV_LOG_DEBUG, " ");
1557 av_log(s->avctx, AV_LOG_DEBUG, "?");
1560 if (IS_INTERLACED(mb_type))
1561 av_log(s->avctx, AV_LOG_DEBUG, "=");
1563 av_log(s->avctx, AV_LOG_DEBUG, " ");
1565 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1567 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1571 if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1572 (s->avctx->debug_mv)) {
1573 const int shift = 1 + s->quarter_sample;
1577 int h_chroma_shift, v_chroma_shift, block_height;
1578 const int width = s->avctx->width;
1579 const int height = s->avctx->height;
1580 const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1581 const int mv_stride = (s->mb_width << mv_sample_log2) +
1582 (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1583 s->low_delay = 0; // needed to see the vectors without trashing the buffers
1585 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1586 &h_chroma_shift, &v_chroma_shift);
1587 for (i = 0; i < 3; i++) {
1588 size_t size= (i == 0) ? pict->linesize[i] * height:
1589 pict->linesize[i] * height >> v_chroma_shift;
1590 s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1591 memcpy(s->visualization_buffer[i], pict->data[i], size);
1592 pict->data[i] = s->visualization_buffer[i];
1594 pict->type = FF_BUFFER_TYPE_COPY;
1596 ptr = pict->data[0];
1597 block_height = 16 >> v_chroma_shift;
1599 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1601 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1602 const int mb_index = mb_x + mb_y * s->mb_stride;
1603 if ((s->avctx->debug_mv) && pict->motion_val) {
1605 for (type = 0; type < 3; type++) {
1609 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1610 (pict->pict_type!= AV_PICTURE_TYPE_P))
1615 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1616 (pict->pict_type!= AV_PICTURE_TYPE_B))
1621 if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1622 (pict->pict_type!= AV_PICTURE_TYPE_B))
1627 if (!USES_LIST(pict->mb_type[mb_index], direction))
1630 if (IS_8X8(pict->mb_type[mb_index])) {
1632 for (i = 0; i < 4; i++) {
1633 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1634 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1635 int xy = (mb_x * 2 + (i & 1) +
1636 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1637 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1638 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1639 draw_arrow(ptr, sx, sy, mx, my, width,
1640 height, s->linesize, 100);
1642 } else if (IS_16X8(pict->mb_type[mb_index])) {
1644 for (i = 0; i < 2; i++) {
1645 int sx = mb_x * 16 + 8;
1646 int sy = mb_y * 16 + 4 + 8 * i;
1647 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1648 int mx = (pict->motion_val[direction][xy][0] >> shift);
1649 int my = (pict->motion_val[direction][xy][1] >> shift);
1651 if (IS_INTERLACED(pict->mb_type[mb_index]))
1654 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1655 height, s->linesize, 100);
1657 } else if (IS_8X16(pict->mb_type[mb_index])) {
1659 for (i = 0; i < 2; i++) {
1660 int sx = mb_x * 16 + 4 + 8 * i;
1661 int sy = mb_y * 16 + 8;
1662 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1663 int mx = pict->motion_val[direction][xy][0] >> shift;
1664 int my = pict->motion_val[direction][xy][1] >> shift;
1666 if (IS_INTERLACED(pict->mb_type[mb_index]))
1669 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1670 height, s->linesize, 100);
1673 int sx= mb_x * 16 + 8;
1674 int sy= mb_y * 16 + 8;
1675 int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1676 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1677 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1678 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1682 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1683 uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1684 0x0101010101010101ULL;
1686 for (y = 0; y < block_height; y++) {
1687 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1688 (block_height * mb_y + y) *
1689 pict->linesize[1]) = c;
1690 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1691 (block_height * mb_y + y) *
1692 pict->linesize[2]) = c;
1695 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1697 int mb_type = pict->mb_type[mb_index];
1700 #define COLOR(theta, r) \
1701 u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1702 v = (int)(128 + r * sin(theta * 3.141592 / 180));
1706 if (IS_PCM(mb_type)) {
1708 } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1709 IS_INTRA16x16(mb_type)) {
1711 } else if (IS_INTRA4x4(mb_type)) {
1713 } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1715 } else if (IS_DIRECT(mb_type)) {
1717 } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1719 } else if (IS_GMC(mb_type)) {
1721 } else if (IS_SKIP(mb_type)) {
1723 } else if (!USES_LIST(mb_type, 1)) {
1725 } else if (!USES_LIST(mb_type, 0)) {
1728 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1732 u *= 0x0101010101010101ULL;
1733 v *= 0x0101010101010101ULL;
1734 for (y = 0; y < block_height; y++) {
1735 *(uint64_t *)(pict->data[1] + 8 * mb_x +
1736 (block_height * mb_y + y) * pict->linesize[1]) = u;
1737 *(uint64_t *)(pict->data[2] + 8 * mb_x +
1738 (block_height * mb_y + y) * pict->linesize[2]) = v;
1742 if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1743 *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1744 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1745 *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1746 (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1748 if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1749 for (y = 0; y < 16; y++)
1750 pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1751 pict->linesize[0]] ^= 0x80;
1753 if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1754 int dm = 1 << (mv_sample_log2 - 2);
1755 for (i = 0; i < 4; i++) {
1756 int sx = mb_x * 16 + 8 * (i & 1);
1757 int sy = mb_y * 16 + 8 * (i >> 1);
1758 int xy = (mb_x * 2 + (i & 1) +
1759 (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1761 int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1762 if (mv[0] != mv[dm] ||
1763 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1764 for (y = 0; y < 8; y++)
1765 pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1766 if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1767 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1768 pict->linesize[0]) ^= 0x8080808080808080ULL;
1772 if (IS_INTERLACED(mb_type) &&
1773 s->codec_id == CODEC_ID_H264) {
1777 s->mbskip_table[mb_index] = 0;
1783 static inline int hpel_motion_lowres(MpegEncContext *s,
1784 uint8_t *dest, uint8_t *src,
1785 int field_based, int field_select,
1786 int src_x, int src_y,
1787 int width, int height, int stride,
1788 int h_edge_pos, int v_edge_pos,
1789 int w, int h, h264_chroma_mc_func *pix_op,
1790 int motion_x, int motion_y)
1792 const int lowres = s->avctx->lowres;
1793 const int op_index = FFMIN(lowres, 2);
1794 const int s_mask = (2 << lowres) - 1;
1798 if (s->quarter_sample) {
1803 sx = motion_x & s_mask;
1804 sy = motion_y & s_mask;
1805 src_x += motion_x >> lowres + 1;
1806 src_y += motion_y >> lowres + 1;
1808 src += src_y * stride + src_x;
1810 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1811 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1812 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1813 (h + 1) << field_based, src_x,
1814 src_y << field_based,
1817 src = s->edge_emu_buffer;
1821 sx = (sx << 2) >> lowres;
1822 sy = (sy << 2) >> lowres;
1825 pix_op[op_index](dest, src, stride, h, sx, sy);
1829 /* apply one mpeg motion vector to the three components */
1830 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1837 uint8_t **ref_picture,
1838 h264_chroma_mc_func *pix_op,
1839 int motion_x, int motion_y,
1842 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1843 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1845 const int lowres = s->avctx->lowres;
1846 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 2);
1847 const int block_s = 8>>lowres;
1848 const int s_mask = (2 << lowres) - 1;
1849 const int h_edge_pos = s->h_edge_pos >> lowres;
1850 const int v_edge_pos = s->v_edge_pos >> lowres;
1851 linesize = s->current_picture.f.linesize[0] << field_based;
1852 uvlinesize = s->current_picture.f.linesize[1] << field_based;
1854 // FIXME obviously not perfect but qpel will not work in lowres anyway
1855 if (s->quarter_sample) {
1861 motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1864 sx = motion_x & s_mask;
1865 sy = motion_y & s_mask;
1866 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1867 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1869 if (s->out_format == FMT_H263) {
1870 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1871 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1872 uvsrc_x = src_x >> 1;
1873 uvsrc_y = src_y >> 1;
1874 } else if (s->out_format == FMT_H261) {
1875 // even chroma mv's are full pel in H261
1878 uvsx = (2 * mx) & s_mask;
1879 uvsy = (2 * my) & s_mask;
1880 uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1881 uvsrc_y = mb_y * block_s + (my >> lowres);
1883 if(s->chroma_y_shift){
1888 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1889 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1891 if(s->chroma_x_shift){
1895 uvsy = motion_y & s_mask;
1897 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1900 uvsx = motion_x & s_mask;
1901 uvsy = motion_y & s_mask;
1908 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1909 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1910 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1912 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) ||
1913 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1914 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
1915 s->linesize, 17, 17 + field_based,
1916 src_x, src_y << field_based, h_edge_pos,
1918 ptr_y = s->edge_emu_buffer;
1919 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1920 uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
1921 s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
1923 uvsrc_x, uvsrc_y << field_based,
1924 h_edge_pos >> 1, v_edge_pos >> 1);
1925 s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
1927 uvsrc_x, uvsrc_y << field_based,
1928 h_edge_pos >> 1, v_edge_pos >> 1);
1930 ptr_cr = uvbuf + 16;
1934 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1936 dest_y += s->linesize;
1937 dest_cb += s->uvlinesize;
1938 dest_cr += s->uvlinesize;
1942 ptr_y += s->linesize;
1943 ptr_cb += s->uvlinesize;
1944 ptr_cr += s->uvlinesize;
1947 sx = (sx << 2) >> lowres;
1948 sy = (sy << 2) >> lowres;
1949 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1951 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1952 uvsx = (uvsx << 2) >> lowres;
1953 uvsy = (uvsy << 2) >> lowres;
1954 if (h >> s->chroma_y_shift) {
1955 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1956 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1959 // FIXME h261 lowres loop filter
1962 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1963 uint8_t *dest_cb, uint8_t *dest_cr,
1964 uint8_t **ref_picture,
1965 h264_chroma_mc_func * pix_op,
1968 const int lowres = s->avctx->lowres;
1969 const int op_index = FFMIN(lowres, 2);
1970 const int block_s = 8 >> lowres;
1971 const int s_mask = (2 << lowres) - 1;
1972 const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1973 const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1974 int emu = 0, src_x, src_y, offset, sx, sy;
1977 if (s->quarter_sample) {
1982 /* In case of 8X8, we construct a single chroma motion vector
1983 with a special rounding */
1984 mx = ff_h263_round_chroma(mx);
1985 my = ff_h263_round_chroma(my);
1989 src_x = s->mb_x * block_s + (mx >> lowres + 1);
1990 src_y = s->mb_y * block_s + (my >> lowres + 1);
1992 offset = src_y * s->uvlinesize + src_x;
1993 ptr = ref_picture[1] + offset;
1994 if (s->flags & CODEC_FLAG_EMU_EDGE) {
1995 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1996 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1997 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
1998 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1999 ptr = s->edge_emu_buffer;
2003 sx = (sx << 2) >> lowres;
2004 sy = (sy << 2) >> lowres;
2005 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2007 ptr = ref_picture[2] + offset;
2009 s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2010 src_x, src_y, h_edge_pos, v_edge_pos);
2011 ptr = s->edge_emu_buffer;
2013 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2017 * motion compensation of a single macroblock
2019 * @param dest_y luma destination pointer
2020 * @param dest_cb chroma cb/u destination pointer
2021 * @param dest_cr chroma cr/v destination pointer
2022 * @param dir direction (0->forward, 1->backward)
2023 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2024 * @param pix_op halfpel motion compensation function (average or put normally)
2025 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2027 static inline void MPV_motion_lowres(MpegEncContext *s,
2028 uint8_t *dest_y, uint8_t *dest_cb,
2030 int dir, uint8_t **ref_picture,
2031 h264_chroma_mc_func *pix_op)
2035 const int lowres = s->avctx->lowres;
2036 const int block_s = 8 >>lowres;
2041 switch (s->mv_type) {
2043 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2045 ref_picture, pix_op,
2046 s->mv[dir][0][0], s->mv[dir][0][1],
2052 for (i = 0; i < 4; i++) {
2053 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2054 s->linesize) * block_s,
2055 ref_picture[0], 0, 0,
2056 (2 * mb_x + (i & 1)) * block_s,
2057 (2 * mb_y + (i >> 1)) * block_s,
2058 s->width, s->height, s->linesize,
2059 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2060 block_s, block_s, pix_op,
2061 s->mv[dir][i][0], s->mv[dir][i][1]);
2063 mx += s->mv[dir][i][0];
2064 my += s->mv[dir][i][1];
2067 if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2068 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2072 if (s->picture_structure == PICT_FRAME) {
2074 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2075 1, 0, s->field_select[dir][0],
2076 ref_picture, pix_op,
2077 s->mv[dir][0][0], s->mv[dir][0][1],
2080 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2081 1, 1, s->field_select[dir][1],
2082 ref_picture, pix_op,
2083 s->mv[dir][1][0], s->mv[dir][1][1],
2086 if (s->picture_structure != s->field_select[dir][0] + 1 &&
2087 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2088 ref_picture = s->current_picture_ptr->f.data;
2091 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2092 0, 0, s->field_select[dir][0],
2093 ref_picture, pix_op,
2095 s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2099 for (i = 0; i < 2; i++) {
2100 uint8_t **ref2picture;
2102 if (s->picture_structure == s->field_select[dir][i] + 1 ||
2103 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2104 ref2picture = ref_picture;
2106 ref2picture = s->current_picture_ptr->f.data;
2109 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2110 0, 0, s->field_select[dir][i],
2111 ref2picture, pix_op,
2112 s->mv[dir][i][0], s->mv[dir][i][1] +
2113 2 * block_s * i, block_s, mb_y >> 1);
2115 dest_y += 2 * block_s * s->linesize;
2116 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2117 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2121 if (s->picture_structure == PICT_FRAME) {
2122 for (i = 0; i < 2; i++) {
2124 for (j = 0; j < 2; j++) {
2125 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2127 ref_picture, pix_op,
2128 s->mv[dir][2 * i + j][0],
2129 s->mv[dir][2 * i + j][1],
2132 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2135 for (i = 0; i < 2; i++) {
2136 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2137 0, 0, s->picture_structure != i + 1,
2138 ref_picture, pix_op,
2139 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2140 2 * block_s, mb_y >> 1);
2142 // after put we make avg of the same block
2143 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2145 // opposite parity is always in the same
2146 // frame if this is second field
2147 if (!s->first_field) {
2148 ref_picture = s->current_picture_ptr->f.data;
2159 * find the lowest MB row referenced in the MVs
2161 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2163 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2164 int my, off, i, mvs;
2166 if (s->picture_structure != PICT_FRAME) goto unhandled;
2168 switch (s->mv_type) {
2182 for (i = 0; i < mvs; i++) {
2183 my = s->mv[dir][i][1]<<qpel_shift;
2184 my_max = FFMAX(my_max, my);
2185 my_min = FFMIN(my_min, my);
2188 off = (FFMAX(-my_min, my_max) + 63) >> 6;
2190 return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2192 return s->mb_height-1;
2195 /* put block[] to dest[] */
2196 static inline void put_dct(MpegEncContext *s,
2197 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2199 s->dct_unquantize_intra(s, block, i, qscale);
2200 s->dsp.idct_put (dest, line_size, block);
2203 /* add block[] to dest[] */
2204 static inline void add_dct(MpegEncContext *s,
2205 DCTELEM *block, int i, uint8_t *dest, int line_size)
2207 if (s->block_last_index[i] >= 0) {
2208 s->dsp.idct_add (dest, line_size, block);
2212 static inline void add_dequant_dct(MpegEncContext *s,
2213 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2215 if (s->block_last_index[i] >= 0) {
2216 s->dct_unquantize_inter(s, block, i, qscale);
2218 s->dsp.idct_add (dest, line_size, block);
2223 * Clean dc, ac, coded_block for the current non-intra MB.
2225 void ff_clean_intra_table_entries(MpegEncContext *s)
2227 int wrap = s->b8_stride;
2228 int xy = s->block_index[0];
2231 s->dc_val[0][xy + 1 ] =
2232 s->dc_val[0][xy + wrap] =
2233 s->dc_val[0][xy + 1 + wrap] = 1024;
2235 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
2236 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2237 if (s->msmpeg4_version>=3) {
2238 s->coded_block[xy ] =
2239 s->coded_block[xy + 1 ] =
2240 s->coded_block[xy + wrap] =
2241 s->coded_block[xy + 1 + wrap] = 0;
2244 wrap = s->mb_stride;
2245 xy = s->mb_x + s->mb_y * wrap;
2247 s->dc_val[2][xy] = 1024;
2249 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2250 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2252 s->mbintra_table[xy]= 0;
2255 /* generic function called after a macroblock has been parsed by the
2256 decoder or after it has been encoded by the encoder.
2258 Important variables used:
2259 s->mb_intra : true if intra macroblock
2260 s->mv_dir : motion vector direction
2261 s->mv_type : motion vector type
2262 s->mv : motion vector
2263 s->interlaced_dct : true if interlaced dct used (mpeg2)
2265 static av_always_inline
2266 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2267 int lowres_flag, int is_mpeg12)
2269 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2270 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2271 ff_xvmc_decode_mb(s);//xvmc uses pblocks
2275 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2276 /* save DCT coefficients */
2278 DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2279 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2281 for(j=0; j<64; j++){
2282 *dct++ = block[i][s->dsp.idct_permutation[j]];
2283 av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2285 av_log(s->avctx, AV_LOG_DEBUG, "\n");
2289 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2291 /* update DC predictors for P macroblocks */
2293 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2294 if(s->mbintra_table[mb_xy])
2295 ff_clean_intra_table_entries(s);
2299 s->last_dc[2] = 128 << s->intra_dc_precision;
2302 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2303 s->mbintra_table[mb_xy]=1;
2305 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
2306 uint8_t *dest_y, *dest_cb, *dest_cr;
2307 int dct_linesize, dct_offset;
2308 op_pixels_func (*op_pix)[4];
2309 qpel_mc_func (*op_qpix)[16];
2310 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2311 const int uvlinesize = s->current_picture.f.linesize[1];
2312 const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2313 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2315 /* avoid copy if macroblock skipped in last frame too */
2316 /* skip only during decoding as we might trash the buffers during encoding a bit */
2318 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2320 if (s->mb_skipped) {
2322 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2324 } else if(!s->current_picture.f.reference) {
2327 *mbskip_ptr = 0; /* not skipped */
2331 dct_linesize = linesize << s->interlaced_dct;
2332 dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2336 dest_cb= s->dest[1];
2337 dest_cr= s->dest[2];
2339 dest_y = s->b_scratchpad;
2340 dest_cb= s->b_scratchpad+16*linesize;
2341 dest_cr= s->b_scratchpad+32*linesize;
2345 /* motion handling */
2346 /* decoding or more than one mb_type (MC was already done otherwise) */
2349 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2350 if (s->mv_dir & MV_DIR_FORWARD) {
2351 ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2353 if (s->mv_dir & MV_DIR_BACKWARD) {
2354 ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2359 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2361 if (s->mv_dir & MV_DIR_FORWARD) {
2362 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2363 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2365 if (s->mv_dir & MV_DIR_BACKWARD) {
2366 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2369 op_qpix= s->me.qpel_put;
2370 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2371 op_pix = s->dsp.put_pixels_tab;
2373 op_pix = s->dsp.put_no_rnd_pixels_tab;
2375 if (s->mv_dir & MV_DIR_FORWARD) {
2376 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2377 op_pix = s->dsp.avg_pixels_tab;
2378 op_qpix= s->me.qpel_avg;
2380 if (s->mv_dir & MV_DIR_BACKWARD) {
2381 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2386 /* skip dequant / idct if we are really late ;) */
2387 if(s->avctx->skip_idct){
2388 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2389 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2390 || s->avctx->skip_idct >= AVDISCARD_ALL)
2394 /* add dct residue */
2395 if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2396 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2397 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2398 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2399 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2400 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2402 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2403 if (s->chroma_y_shift){
2404 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2405 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2409 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2410 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2411 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2412 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2415 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2416 add_dct(s, block[0], 0, dest_y , dct_linesize);
2417 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2418 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2419 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2421 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2422 if(s->chroma_y_shift){//Chroma420
2423 add_dct(s, block[4], 4, dest_cb, uvlinesize);
2424 add_dct(s, block[5], 5, dest_cr, uvlinesize);
2427 dct_linesize = uvlinesize << s->interlaced_dct;
2428 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2430 add_dct(s, block[4], 4, dest_cb, dct_linesize);
2431 add_dct(s, block[5], 5, dest_cr, dct_linesize);
2432 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2433 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2434 if(!s->chroma_x_shift){//Chroma444
2435 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2436 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2437 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2438 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2443 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2444 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2447 /* dct only in intra block */
2448 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2449 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2450 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2451 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2452 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2454 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2455 if(s->chroma_y_shift){
2456 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2457 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2461 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2462 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2463 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2464 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2468 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2469 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2470 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2471 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2473 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2474 if(s->chroma_y_shift){
2475 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2476 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2479 dct_linesize = uvlinesize << s->interlaced_dct;
2480 dct_offset = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2482 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2483 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2484 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2485 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2486 if(!s->chroma_x_shift){//Chroma444
2487 s->dsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2488 s->dsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2489 s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2490 s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2498 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2499 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2500 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2505 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2507 if(s->out_format == FMT_MPEG1) {
2508 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2509 else MPV_decode_mb_internal(s, block, 0, 1);
2512 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2513 else MPV_decode_mb_internal(s, block, 0, 0);
2517 * @param h is the normal height, this will be reduced automatically if needed for the last row
2519 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2520 const int field_pic= s->picture_structure != PICT_FRAME;
2526 if (!s->avctx->hwaccel
2527 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2528 && s->unrestricted_mv
2529 && s->current_picture.f.reference
2531 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2532 int sides = 0, edge_h;
2533 int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2534 int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2535 if (y==0) sides |= EDGE_TOP;
2536 if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2538 edge_h= FFMIN(h, s->v_edge_pos - y);
2540 s->dsp.draw_edges(s->current_picture_ptr->f.data[0] + y *s->linesize,
2541 s->linesize, s->h_edge_pos, edge_h,
2542 EDGE_WIDTH, EDGE_WIDTH, sides);
2543 s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2544 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2545 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2546 s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2547 s->uvlinesize, s->h_edge_pos>>hshift, edge_h>>vshift,
2548 EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2551 h= FFMIN(h, s->avctx->height - y);
2553 if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2555 if (s->avctx->draw_horiz_band) {
2557 int offset[AV_NUM_DATA_POINTERS];
2560 if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2561 src= (AVFrame*)s->current_picture_ptr;
2562 else if(s->last_picture_ptr)
2563 src= (AVFrame*)s->last_picture_ptr;
2567 if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2568 for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2571 offset[0]= y * s->linesize;
2573 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2574 for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2580 s->avctx->draw_horiz_band(s->avctx, src, offset,
2581 y, s->picture_structure, h);
2585 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2586 const int linesize = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2587 const int uvlinesize = s->current_picture.f.linesize[1];
2588 const int mb_size= 4 - s->avctx->lowres;
2590 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2591 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2592 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2593 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2594 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2595 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;
2596 //block_index is not used by mpeg2, so it is not affected by chroma_format
2598 s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) << mb_size);
2599 s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2600 s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2602 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2604 if(s->picture_structure==PICT_FRAME){
2605 s->dest[0] += s->mb_y * linesize << mb_size;
2606 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2607 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2609 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2610 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2611 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2612 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2617 void ff_mpeg_flush(AVCodecContext *avctx){
2619 MpegEncContext *s = avctx->priv_data;
2621 if(s==NULL || s->picture==NULL)
2624 for(i=0; i<s->picture_count; i++){
2625 if (s->picture[i].f.data[0] &&
2626 (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2627 s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2628 free_frame_buffer(s, &s->picture[i]);
2630 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2632 s->mb_x= s->mb_y= 0;
2635 s->parse_context.state= -1;
2636 s->parse_context.frame_start_found= 0;
2637 s->parse_context.overread= 0;
2638 s->parse_context.overread_index= 0;
2639 s->parse_context.index= 0;
2640 s->parse_context.last_index= 0;
2641 s->bitstream_buffer_size=0;
2645 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2646 DCTELEM *block, int n, int qscale)
2648 int i, level, nCoeffs;
2649 const uint16_t *quant_matrix;
2651 nCoeffs= s->block_last_index[n];
2654 block[0] = block[0] * s->y_dc_scale;
2656 block[0] = block[0] * s->c_dc_scale;
2657 /* XXX: only mpeg1 */
2658 quant_matrix = s->intra_matrix;
2659 for(i=1;i<=nCoeffs;i++) {
2660 int j= s->intra_scantable.permutated[i];
2665 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2666 level = (level - 1) | 1;
2669 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2670 level = (level - 1) | 1;
2677 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2678 DCTELEM *block, int n, int qscale)
2680 int i, level, nCoeffs;
2681 const uint16_t *quant_matrix;
2683 nCoeffs= s->block_last_index[n];
2685 quant_matrix = s->inter_matrix;
2686 for(i=0; i<=nCoeffs; i++) {
2687 int j= s->intra_scantable.permutated[i];
2692 level = (((level << 1) + 1) * qscale *
2693 ((int) (quant_matrix[j]))) >> 4;
2694 level = (level - 1) | 1;
2697 level = (((level << 1) + 1) * qscale *
2698 ((int) (quant_matrix[j]))) >> 4;
2699 level = (level - 1) | 1;
2706 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2707 DCTELEM *block, int n, int qscale)
2709 int i, level, nCoeffs;
2710 const uint16_t *quant_matrix;
2712 if(s->alternate_scan) nCoeffs= 63;
2713 else nCoeffs= s->block_last_index[n];
2716 block[0] = block[0] * s->y_dc_scale;
2718 block[0] = block[0] * s->c_dc_scale;
2719 quant_matrix = s->intra_matrix;
2720 for(i=1;i<=nCoeffs;i++) {
2721 int j= s->intra_scantable.permutated[i];
2726 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2729 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2736 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2737 DCTELEM *block, int n, int qscale)
2739 int i, level, nCoeffs;
2740 const uint16_t *quant_matrix;
2743 if(s->alternate_scan) nCoeffs= 63;
2744 else nCoeffs= s->block_last_index[n];
2747 block[0] = block[0] * s->y_dc_scale;
2749 block[0] = block[0] * s->c_dc_scale;
2750 quant_matrix = s->intra_matrix;
2751 for(i=1;i<=nCoeffs;i++) {
2752 int j= s->intra_scantable.permutated[i];
2757 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2760 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2769 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2770 DCTELEM *block, int n, int qscale)
2772 int i, level, nCoeffs;
2773 const uint16_t *quant_matrix;
2776 if(s->alternate_scan) nCoeffs= 63;
2777 else nCoeffs= s->block_last_index[n];
2779 quant_matrix = s->inter_matrix;
2780 for(i=0; i<=nCoeffs; i++) {
2781 int j= s->intra_scantable.permutated[i];
2786 level = (((level << 1) + 1) * qscale *
2787 ((int) (quant_matrix[j]))) >> 4;
2790 level = (((level << 1) + 1) * qscale *
2791 ((int) (quant_matrix[j]))) >> 4;
2800 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2801 DCTELEM *block, int n, int qscale)
2803 int i, level, qmul, qadd;
2806 assert(s->block_last_index[n]>=0);
2812 block[0] = block[0] * s->y_dc_scale;
2814 block[0] = block[0] * s->c_dc_scale;
2815 qadd = (qscale - 1) | 1;
2822 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2824 for(i=1; i<=nCoeffs; i++) {
2828 level = level * qmul - qadd;
2830 level = level * qmul + qadd;
2837 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2838 DCTELEM *block, int n, int qscale)
2840 int i, level, qmul, qadd;
2843 assert(s->block_last_index[n]>=0);
2845 qadd = (qscale - 1) | 1;
2848 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2850 for(i=0; i<=nCoeffs; i++) {
2854 level = level * qmul - qadd;
2856 level = level * qmul + qadd;
2864 * set qscale and update qscale dependent variables.
2866 void ff_set_qscale(MpegEncContext * s, int qscale)
2870 else if (qscale > 31)
2874 s->chroma_qscale= s->chroma_qscale_table[qscale];
2876 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2877 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2880 void MPV_report_decode_progress(MpegEncContext *s)
2882 if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2883 ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);