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 Libav.
10
* Libav is free software; you can redistribute it and/or
11
* modify it under the terms of the GNU Lesser General Public
12
* License as published by the Free Software Foundation; either
13
* version 2.1 of the License, or (at your option) any later version.
15
* Libav is distributed in the hope that it will be useful,
16
* but WITHOUT ANY WARRANTY; without even the implied warranty of
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18
* Lesser General Public License for more details.
20
* You should have received a copy of the GNU Lesser General Public
21
* License along with Libav; if not, write to the Free Software
22
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
71
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
74
const uint8_t ff_mpeg1_dc_scale_table[128]={
75
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
76
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77
8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 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, 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, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82
static const uint8_t mpeg2_dc_scale_table1[128]={
83
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
84
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
85
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
86
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90
static const uint8_t mpeg2_dc_scale_table2[128]={
91
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
92
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
98
static const uint8_t mpeg2_dc_scale_table3[128]={
99
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
100
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
102
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
103
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
106
const uint8_t * const ff_mpeg2_dc_scale_table[4]={
107
ff_mpeg1_dc_scale_table,
108
mpeg2_dc_scale_table1,
109
mpeg2_dc_scale_table2,
110
mpeg2_dc_scale_table3,
113
const enum PixelFormat ff_pixfmt_list_420[] = {
118
const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
125
const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
133
uint32_t tmp= *state << 8;
134
*state= tmp + *(p++);
135
if(tmp == 0x100 || p==end)
140
if (p[-1] > 1 ) p+= 3;
141
else if(p[-2] ) p+= 2;
142
else if(p[-3]|(p[-1]-1)) p++;
155
/* init common dct for both encoder and decoder */
156
av_cold int ff_dct_common_init(MpegEncContext *s)
158
s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
159
s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
160
s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
161
s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
162
s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
163
if(s->flags & CODEC_FLAG_BITEXACT)
164
s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
165
s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
168
MPV_common_init_mmx(s);
170
MPV_common_init_axp(s);
172
MPV_common_init_mlib(s);
174
MPV_common_init_mmi(s);
176
MPV_common_init_arm(s);
178
MPV_common_init_altivec(s);
180
MPV_common_init_bfin(s);
183
/* load & permutate scantables
184
note: only wmv uses different ones
186
if(s->alternate_scan){
187
ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
188
ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
190
ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
191
ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
193
ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
194
ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
199
void ff_copy_picture(Picture *dst, Picture *src){
201
dst->type= FF_BUFFER_TYPE_COPY;
205
* Release a frame buffer
207
static void free_frame_buffer(MpegEncContext *s, Picture *pic)
209
ff_thread_release_buffer(s->avctx, (AVFrame*)pic);
210
av_freep(&pic->hwaccel_picture_private);
214
* Allocate a frame buffer
216
static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
220
if (s->avctx->hwaccel) {
221
assert(!pic->hwaccel_picture_private);
222
if (s->avctx->hwaccel->priv_data_size) {
223
pic->hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
224
if (!pic->hwaccel_picture_private) {
225
av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
231
r = ff_thread_get_buffer(s->avctx, (AVFrame*)pic);
233
if (r<0 || !pic->age || !pic->type || !pic->data[0]) {
234
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
235
av_freep(&pic->hwaccel_picture_private);
239
if (s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])) {
240
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
241
free_frame_buffer(s, pic);
245
if (pic->linesize[1] != pic->linesize[2]) {
246
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
247
free_frame_buffer(s, pic);
255
* allocates a Picture
256
* The pixels are allocated/set by calling get_buffer() if shared=0
258
int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
259
const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
260
const int mb_array_size= s->mb_stride*s->mb_height;
261
const int b8_array_size= s->b8_stride*s->mb_height*2;
262
const int b4_array_size= s->b4_stride*s->mb_height*4;
267
assert(pic->data[0]);
268
assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
269
pic->type= FF_BUFFER_TYPE_SHARED;
271
assert(!pic->data[0]);
273
if (alloc_frame_buffer(s, pic) < 0)
276
s->linesize = pic->linesize[0];
277
s->uvlinesize= pic->linesize[1];
280
if(pic->qscale_table==NULL){
282
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var , mb_array_size * sizeof(int16_t) , fail)
283
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var, mb_array_size * sizeof(int16_t) , fail)
284
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean , mb_array_size * sizeof(int8_t ) , fail)
287
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2, fail) //the +2 is for the slice end check
288
FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table , mb_array_size * sizeof(uint8_t) , fail)
289
FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t), fail)
290
pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
291
if(s->out_format == FMT_H264){
293
FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t), fail)
294
pic->motion_val[i]= pic->motion_val_base[i]+4;
295
FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
297
pic->motion_subsample_log2= 2;
298
}else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
300
FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
301
pic->motion_val[i]= pic->motion_val_base[i]+4;
302
FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
304
pic->motion_subsample_log2= 3;
306
if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
307
FF_ALLOCZ_OR_GOTO(s->avctx, pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6, fail)
309
pic->qstride= s->mb_stride;
310
FF_ALLOCZ_OR_GOTO(s->avctx, pic->pan_scan , 1 * sizeof(AVPanScan), fail)
313
/* It might be nicer if the application would keep track of these
314
* but it would require an API change. */
315
memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
316
s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
317
if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == AV_PICTURE_TYPE_B)
318
pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
322
fail: //for the FF_ALLOCZ_OR_GOTO macro
324
free_frame_buffer(s, pic);
329
* deallocates a picture
331
static void free_picture(MpegEncContext *s, Picture *pic){
334
if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
335
free_frame_buffer(s, pic);
338
av_freep(&pic->mb_var);
339
av_freep(&pic->mc_mb_var);
340
av_freep(&pic->mb_mean);
341
av_freep(&pic->mbskip_table);
342
av_freep(&pic->qscale_table);
343
av_freep(&pic->mb_type_base);
344
av_freep(&pic->dct_coeff);
345
av_freep(&pic->pan_scan);
348
av_freep(&pic->motion_val_base[i]);
349
av_freep(&pic->ref_index[i]);
352
if(pic->type == FF_BUFFER_TYPE_SHARED){
361
static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
362
int y_size = s->b8_stride * (2 * s->mb_height + 1);
363
int c_size = s->mb_stride * (s->mb_height + 1);
364
int yc_size = y_size + 2 * c_size;
367
// edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
368
FF_ALLOCZ_OR_GOTO(s->avctx, s->allocated_edge_emu_buffer, (s->width+64)*2*21*2, fail); //(width + edge + align)*interlaced*MBsize*tolerance
369
s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
371
//FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
372
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t), fail)
373
s->me.temp= s->me.scratchpad;
374
s->rd_scratchpad= s->me.scratchpad;
375
s->b_scratchpad= s->me.scratchpad;
376
s->obmc_scratchpad= s->me.scratchpad + 16;
378
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map , ME_MAP_SIZE*sizeof(uint32_t), fail)
379
FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
380
if(s->avctx->noise_reduction){
381
FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
384
FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
385
s->block= s->blocks[0];
388
s->pblocks[i] = &s->block[i];
391
if (s->out_format == FMT_H263) {
393
FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
394
s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
395
s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
396
s->ac_val[2] = s->ac_val[1] + c_size;
401
return -1; //free() through MPV_common_end()
404
static void free_duplicate_context(MpegEncContext *s){
407
av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
408
av_freep(&s->me.scratchpad);
412
s->obmc_scratchpad= NULL;
414
av_freep(&s->dct_error_sum);
415
av_freep(&s->me.map);
416
av_freep(&s->me.score_map);
417
av_freep(&s->blocks);
418
av_freep(&s->ac_val_base);
422
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
423
#define COPY(a) bak->a= src->a
424
COPY(allocated_edge_emu_buffer);
425
COPY(edge_emu_buffer);
430
COPY(obmc_scratchpad);
437
COPY(me.map_generation);
449
void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
452
//FIXME copy only needed parts
454
backup_duplicate_context(&bak, dst);
455
memcpy(dst, src, sizeof(MpegEncContext));
456
backup_duplicate_context(dst, &bak);
458
dst->pblocks[i] = &dst->block[i];
460
//STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
463
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
465
MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
467
if(dst == src || !s1->context_initialized) return 0;
469
//FIXME can parameters change on I-frames? in that case dst may need a reinit
470
if(!s->context_initialized){
471
memcpy(s, s1, sizeof(MpegEncContext));
474
s->picture_range_start += MAX_PICTURE_COUNT;
475
s->picture_range_end += MAX_PICTURE_COUNT;
476
s->bitstream_buffer = NULL;
477
s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
482
s->avctx->coded_height = s1->avctx->coded_height;
483
s->avctx->coded_width = s1->avctx->coded_width;
484
s->avctx->width = s1->avctx->width;
485
s->avctx->height = s1->avctx->height;
487
s->coded_picture_number = s1->coded_picture_number;
488
s->picture_number = s1->picture_number;
489
s->input_picture_number = s1->input_picture_number;
491
memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
492
memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
494
s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
495
s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
496
s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
498
memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
500
//Error/bug resilience
501
s->next_p_frame_damaged = s1->next_p_frame_damaged;
502
s->workaround_bugs = s1->workaround_bugs;
505
memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
508
s->max_b_frames = s1->max_b_frames;
509
s->low_delay = s1->low_delay;
510
s->dropable = s1->dropable;
512
//DivX handling (doesn't work)
513
s->divx_packed = s1->divx_packed;
515
if(s1->bitstream_buffer){
516
if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
517
av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
518
s->bitstream_buffer_size = s1->bitstream_buffer_size;
519
memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
520
memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
523
//MPEG2/interlacing info
524
memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
526
if(!s1->first_field){
527
s->last_pict_type= s1->pict_type;
528
if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->quality;
530
if(s1->pict_type!=FF_B_TYPE){
531
s->last_non_b_pict_type= s1->pict_type;
539
* sets the given MpegEncContext to common defaults (same for encoding and decoding).
540
* the changed fields will not depend upon the prior state of the MpegEncContext.
542
void MPV_common_defaults(MpegEncContext *s){
544
s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
545
s->chroma_qscale_table= ff_default_chroma_qscale_table;
546
s->progressive_frame= 1;
547
s->progressive_sequence= 1;
548
s->picture_structure= PICT_FRAME;
550
s->coded_picture_number = 0;
551
s->picture_number = 0;
552
s->input_picture_number = 0;
554
s->picture_in_gop_number = 0;
559
s->picture_range_start = 0;
560
s->picture_range_end = MAX_PICTURE_COUNT;
564
* sets the given MpegEncContext to defaults for decoding.
565
* the changed fields will not depend upon the prior state of the MpegEncContext.
567
void MPV_decode_defaults(MpegEncContext *s){
568
MPV_common_defaults(s);
572
* init common structure for both encoder and decoder.
573
* this assumes that some variables like width/height are already set
575
av_cold int MPV_common_init(MpegEncContext *s)
577
int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
579
if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
580
s->mb_height = (s->height + 31) / 32 * 2;
581
else if (s->codec_id != CODEC_ID_H264)
582
s->mb_height = (s->height + 15) / 16;
584
if(s->avctx->pix_fmt == PIX_FMT_NONE){
585
av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
589
if((s->encoding || (s->avctx->active_thread_type & FF_THREAD_SLICE)) &&
590
(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
591
av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
595
if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
598
dsputil_init(&s->dsp, s->avctx);
599
ff_dct_common_init(s);
601
s->flags= s->avctx->flags;
602
s->flags2= s->avctx->flags2;
604
if (s->width && s->height) {
605
s->mb_width = (s->width + 15) / 16;
606
s->mb_stride = s->mb_width + 1;
607
s->b8_stride = s->mb_width*2 + 1;
608
s->b4_stride = s->mb_width*4 + 1;
609
mb_array_size= s->mb_height * s->mb_stride;
610
mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
612
/* set chroma shifts */
613
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
614
&(s->chroma_y_shift) );
616
/* set default edge pos, will be overriden in decode_header if needed */
617
s->h_edge_pos= s->mb_width*16;
618
s->v_edge_pos= s->mb_height*16;
620
s->mb_num = s->mb_width * s->mb_height;
625
s->block_wrap[3]= s->b8_stride;
627
s->block_wrap[5]= s->mb_stride;
629
y_size = s->b8_stride * (2 * s->mb_height + 1);
630
c_size = s->mb_stride * (s->mb_height + 1);
631
yc_size = y_size + 2 * c_size;
633
/* convert fourcc to upper case */
634
s->codec_tag = ff_toupper4(s->avctx->codec_tag);
636
s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
638
s->avctx->coded_frame= (AVFrame*)&s->current_picture;
640
FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
641
for(y=0; y<s->mb_height; y++){
642
for(x=0; x<s->mb_width; x++){
643
s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
646
s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
649
/* Allocate MV tables */
650
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
651
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
652
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
653
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
654
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
655
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
656
s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
657
s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
658
s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
659
s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
660
s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
661
s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
663
if(s->msmpeg4_version){
664
FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
666
FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
668
/* Allocate MB type table */
669
FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
671
FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
673
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
674
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
675
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
676
FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
677
FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
678
FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
680
if(s->avctx->noise_reduction){
681
FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
686
s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
687
FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
688
for(i = 0; i < s->picture_count; i++) {
689
avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
692
if (s->width && s->height) {
693
FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
695
if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
696
/* interlaced direct mode decoding tables */
701
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
702
s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
704
FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
705
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
706
s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
708
FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
711
if (s->out_format == FMT_H263) {
713
FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
714
s->coded_block= s->coded_block_base + s->b8_stride + 1;
716
/* cbp, ac_pred, pred_dir */
717
FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail)
718
FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
721
if (s->h263_pred || s->h263_plus || !s->encoding) {
723
//MN: we need these for error resilience of intra-frames
724
FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
725
s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
726
s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
727
s->dc_val[2] = s->dc_val[1] + c_size;
728
for(i=0;i<yc_size;i++)
729
s->dc_val_base[i] = 1024;
732
/* which mb is a intra block */
733
FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
734
memset(s->mbintra_table, 1, mb_array_size);
736
/* init macroblock skip table */
737
FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
738
//Note the +1 is for a quicker mpeg4 slice_end detection
739
FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
741
s->parse_context.state= -1;
742
if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
743
s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
744
s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
745
s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
749
s->context_initialized = 1;
750
s->thread_context[0]= s;
752
if (s->width && s->height) {
753
if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
754
threads = s->avctx->thread_count;
756
for(i=1; i<threads; i++){
757
s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
758
memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
761
for(i=0; i<threads; i++){
762
if(init_duplicate_context(s->thread_context[i], s) < 0)
764
s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
765
s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
768
if(init_duplicate_context(s, s) < 0) goto fail;
770
s->end_mb_y = s->mb_height;
780
/* init common structure for both encoder and decoder */
781
void MPV_common_end(MpegEncContext *s)
785
if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
786
for(i=0; i<s->avctx->thread_count; i++){
787
free_duplicate_context(s->thread_context[i]);
789
for(i=1; i<s->avctx->thread_count; i++){
790
av_freep(&s->thread_context[i]);
792
} else free_duplicate_context(s);
794
av_freep(&s->parse_context.buffer);
795
s->parse_context.buffer_size=0;
797
av_freep(&s->mb_type);
798
av_freep(&s->p_mv_table_base);
799
av_freep(&s->b_forw_mv_table_base);
800
av_freep(&s->b_back_mv_table_base);
801
av_freep(&s->b_bidir_forw_mv_table_base);
802
av_freep(&s->b_bidir_back_mv_table_base);
803
av_freep(&s->b_direct_mv_table_base);
805
s->b_forw_mv_table= NULL;
806
s->b_back_mv_table= NULL;
807
s->b_bidir_forw_mv_table= NULL;
808
s->b_bidir_back_mv_table= NULL;
809
s->b_direct_mv_table= NULL;
813
av_freep(&s->b_field_mv_table_base[i][j][k]);
814
s->b_field_mv_table[i][j][k]=NULL;
816
av_freep(&s->b_field_select_table[i][j]);
817
av_freep(&s->p_field_mv_table_base[i][j]);
818
s->p_field_mv_table[i][j]=NULL;
820
av_freep(&s->p_field_select_table[i]);
823
av_freep(&s->dc_val_base);
824
av_freep(&s->coded_block_base);
825
av_freep(&s->mbintra_table);
826
av_freep(&s->cbp_table);
827
av_freep(&s->pred_dir_table);
829
av_freep(&s->mbskip_table);
830
av_freep(&s->prev_pict_types);
831
av_freep(&s->bitstream_buffer);
832
s->allocated_bitstream_buffer_size=0;
834
av_freep(&s->avctx->stats_out);
835
av_freep(&s->ac_stats);
836
av_freep(&s->error_status_table);
837
av_freep(&s->mb_index2xy);
838
av_freep(&s->lambda_table);
839
av_freep(&s->q_intra_matrix);
840
av_freep(&s->q_inter_matrix);
841
av_freep(&s->q_intra_matrix16);
842
av_freep(&s->q_inter_matrix16);
843
av_freep(&s->input_picture);
844
av_freep(&s->reordered_input_picture);
845
av_freep(&s->dct_offset);
847
if(s->picture && !s->avctx->is_copy){
848
for(i=0; i<s->picture_count; i++){
849
free_picture(s, &s->picture[i]);
852
av_freep(&s->picture);
853
s->context_initialized = 0;
856
s->current_picture_ptr= NULL;
857
s->linesize= s->uvlinesize= 0;
860
av_freep(&s->visualization_buffer[i]);
862
if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
863
avcodec_default_free_buffers(s->avctx);
866
void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
868
int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
869
uint8_t index_run[MAX_RUN+1];
870
int last, run, level, start, end, i;
872
/* If table is static, we can quit if rl->max_level[0] is not NULL */
873
if(static_store && rl->max_level[0])
876
/* compute max_level[], max_run[] and index_run[] */
877
for(last=0;last<2;last++) {
886
memset(max_level, 0, MAX_RUN + 1);
887
memset(max_run, 0, MAX_LEVEL + 1);
888
memset(index_run, rl->n, MAX_RUN + 1);
889
for(i=start;i<end;i++) {
890
run = rl->table_run[i];
891
level = rl->table_level[i];
892
if (index_run[run] == rl->n)
894
if (level > max_level[run])
895
max_level[run] = level;
896
if (run > max_run[level])
897
max_run[level] = run;
900
rl->max_level[last] = static_store[last];
902
rl->max_level[last] = av_malloc(MAX_RUN + 1);
903
memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
905
rl->max_run[last] = static_store[last] + MAX_RUN + 1;
907
rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
908
memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
910
rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
912
rl->index_run[last] = av_malloc(MAX_RUN + 1);
913
memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
917
void init_vlc_rl(RLTable *rl)
929
for(i=0; i<rl->vlc.table_size; i++){
930
int code= rl->vlc.table[i][0];
931
int len = rl->vlc.table[i][1];
934
if(len==0){ // illegal code
937
}else if(len<0){ //more bits needed
941
if(code==rl->n){ //esc
945
run= rl->table_run [code] + 1;
946
level= rl->table_level[code] * qmul + qadd;
947
if(code >= rl->last) run+=192;
950
rl->rl_vlc[q][i].len= len;
951
rl->rl_vlc[q][i].level= level;
952
rl->rl_vlc[q][i].run= run;
957
void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
961
/* release non reference frames */
962
for(i=0; i<s->picture_count; i++){
963
if(s->picture[i].data[0] && !s->picture[i].reference
964
&& (!s->picture[i].owner2 || s->picture[i].owner2 == s)
965
&& (remove_current || &s->picture[i] != s->current_picture_ptr)
966
/*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
967
free_frame_buffer(s, &s->picture[i]);
972
int ff_find_unused_picture(MpegEncContext *s, int shared){
976
for(i=s->picture_range_start; i<s->picture_range_end; i++){
977
if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
980
for(i=s->picture_range_start; i<s->picture_range_end; i++){
981
if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
983
for(i=s->picture_range_start; i<s->picture_range_end; i++){
984
if(s->picture[i].data[0]==NULL) return i;
988
av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
989
/* We could return -1, but the codec would crash trying to draw into a
990
* non-existing frame anyway. This is safer than waiting for a random crash.
991
* Also the return of this is never useful, an encoder must only allocate
992
* as much as allowed in the specification. This has no relationship to how
993
* much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
994
* enough for such valid streams).
995
* Plus, a decoder has to check stream validity and remove frames if too
996
* many reference frames are around. Waiting for "OOM" is not correct at
997
* all. Similarly, missing reference frames have to be replaced by
998
* interpolated/MC frames, anything else is a bug in the codec ...
1004
static void update_noise_reduction(MpegEncContext *s){
1007
for(intra=0; intra<2; intra++){
1008
if(s->dct_count[intra] > (1<<16)){
1009
for(i=0; i<64; i++){
1010
s->dct_error_sum[intra][i] >>=1;
1012
s->dct_count[intra] >>= 1;
1015
for(i=0; i<64; i++){
1016
s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1022
* generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1024
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1030
assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1032
/* mark&release old frames */
1033
if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1034
if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1035
free_frame_buffer(s, s->last_picture_ptr);
1037
/* release forgotten pictures */
1038
/* if(mpeg124/h263) */
1040
for(i=0; i<s->picture_count; i++){
1041
if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1042
av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1043
free_frame_buffer(s, &s->picture[i]);
1051
ff_release_unused_pictures(s, 1);
1053
if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1054
pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1056
i= ff_find_unused_picture(s, 0);
1057
pic= &s->picture[i];
1062
if (s->codec_id == CODEC_ID_H264)
1063
pic->reference = s->picture_structure;
1064
else if (s->pict_type != AV_PICTURE_TYPE_B)
1068
pic->coded_picture_number= s->coded_picture_number++;
1070
if(ff_alloc_picture(s, pic, 0) < 0)
1073
s->current_picture_ptr= pic;
1074
//FIXME use only the vars from current_pic
1075
s->current_picture_ptr->top_field_first= s->top_field_first;
1076
if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1077
if(s->picture_structure != PICT_FRAME)
1078
s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1080
s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1081
s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
1084
s->current_picture_ptr->pict_type= s->pict_type;
1085
// if(s->flags && CODEC_FLAG_QSCALE)
1086
// s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1087
s->current_picture_ptr->key_frame= s->pict_type == AV_PICTURE_TYPE_I;
1089
ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1091
if (s->pict_type != AV_PICTURE_TYPE_B) {
1092
s->last_picture_ptr= s->next_picture_ptr;
1094
s->next_picture_ptr= s->current_picture_ptr;
1096
/* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1097
s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1098
s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1099
s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1100
s->pict_type, s->dropable);*/
1102
if(s->codec_id != CODEC_ID_H264){
1103
if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) &&
1104
(s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1105
if (s->pict_type != AV_PICTURE_TYPE_I)
1106
av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1107
else if (s->picture_structure != PICT_FRAME)
1108
av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1110
/* Allocate a dummy frame */
1111
i= ff_find_unused_picture(s, 0);
1112
s->last_picture_ptr= &s->picture[i];
1113
if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1115
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1116
ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1118
if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==AV_PICTURE_TYPE_B){
1119
/* Allocate a dummy frame */
1120
i= ff_find_unused_picture(s, 0);
1121
s->next_picture_ptr= &s->picture[i];
1122
if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1124
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1125
ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1129
if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1130
if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1132
assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1134
if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1137
if(s->picture_structure == PICT_BOTTOM_FIELD){
1138
s->current_picture.data[i] += s->current_picture.linesize[i];
1140
s->current_picture.linesize[i] *= 2;
1141
s->last_picture.linesize[i] *=2;
1142
s->next_picture.linesize[i] *=2;
1146
s->error_recognition= avctx->error_recognition;
1148
/* set dequantizer, we can't do it during init as it might change for mpeg4
1149
and we can't do it in the header decode as init is not called for mpeg4 there yet */
1150
if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1151
s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1152
s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1153
}else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1154
s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1155
s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1157
s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1158
s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1161
if(s->dct_error_sum){
1162
assert(s->avctx->noise_reduction && s->encoding);
1164
update_noise_reduction(s);
1167
if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1168
return ff_xvmc_field_start(s, avctx);
1173
/* generic function for encode/decode called after a frame has been coded/decoded */
1174
void MPV_frame_end(MpegEncContext *s)
1177
/* redraw edges for the frame if decoding didn't complete */
1178
//just to make sure that all data is rendered.
1179
if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1180
ff_xvmc_field_end(s);
1181
}else if((s->error_count || s->encoding)
1182
&& !s->avctx->hwaccel
1183
&& !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1184
&& s->unrestricted_mv
1185
&& s->current_picture.reference
1187
&& !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1188
int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1189
int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1190
s->dsp.draw_edges(s->current_picture.data[0], s->linesize ,
1191
s->h_edge_pos , s->v_edge_pos,
1192
EDGE_WIDTH , EDGE_WIDTH , EDGE_TOP | EDGE_BOTTOM);
1193
s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize,
1194
s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1195
EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1196
s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize,
1197
s->h_edge_pos>>hshift, s->v_edge_pos>>vshift,
1198
EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, EDGE_TOP | EDGE_BOTTOM);
1203
s->last_pict_type = s->pict_type;
1204
s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1205
if(s->pict_type!=AV_PICTURE_TYPE_B){
1206
s->last_non_b_pict_type= s->pict_type;
1209
/* copy back current_picture variables */
1210
for(i=0; i<MAX_PICTURE_COUNT; i++){
1211
if(s->picture[i].data[0] == s->current_picture.data[0]){
1212
s->picture[i]= s->current_picture;
1216
assert(i<MAX_PICTURE_COUNT);
1220
/* release non-reference frames */
1221
for(i=0; i<s->picture_count; i++){
1222
if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1223
free_frame_buffer(s, &s->picture[i]);
1227
// clear copies, to avoid confusion
1229
memset(&s->last_picture, 0, sizeof(Picture));
1230
memset(&s->next_picture, 0, sizeof(Picture));
1231
memset(&s->current_picture, 0, sizeof(Picture));
1233
s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1235
if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1236
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1241
* draws an line from (ex, ey) -> (sx, sy).
1242
* @param w width of the image
1243
* @param h height of the image
1244
* @param stride stride/linesize of the image
1245
* @param color color of the arrow
1247
static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1250
sx= av_clip(sx, 0, w-1);
1251
sy= av_clip(sy, 0, h-1);
1252
ex= av_clip(ex, 0, w-1);
1253
ey= av_clip(ey, 0, h-1);
1255
buf[sy*stride + sx]+= color;
1257
if(FFABS(ex - sx) > FFABS(ey - sy)){
1259
FFSWAP(int, sx, ex);
1260
FFSWAP(int, sy, ey);
1262
buf+= sx + sy*stride;
1264
f= ((ey-sy)<<16)/ex;
1265
for(x= 0; x <= ex; x++){
1268
buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1269
buf[(y+1)*stride + x]+= (color* fr )>>16;
1273
FFSWAP(int, sx, ex);
1274
FFSWAP(int, sy, ey);
1276
buf+= sx + sy*stride;
1278
if(ey) f= ((ex-sx)<<16)/ey;
1280
for(y= 0; y <= ey; y++){
1283
buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1284
buf[y*stride + x+1]+= (color* fr )>>16;
1290
* draws an arrow from (ex, ey) -> (sx, sy).
1291
* @param w width of the image
1292
* @param h height of the image
1293
* @param stride stride/linesize of the image
1294
* @param color color of the arrow
1296
static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1299
sx= av_clip(sx, -100, w+100);
1300
sy= av_clip(sy, -100, h+100);
1301
ex= av_clip(ex, -100, w+100);
1302
ey= av_clip(ey, -100, h+100);
1307
if(dx*dx + dy*dy > 3*3){
1310
int length= ff_sqrt((rx*rx + ry*ry)<<8);
1312
//FIXME subpixel accuracy
1313
rx= ROUNDED_DIV(rx*3<<4, length);
1314
ry= ROUNDED_DIV(ry*3<<4, length);
1316
draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1317
draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1319
draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1323
* prints debuging info for the given picture.
1325
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1327
if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1329
if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1332
av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1333
switch (pict->pict_type) {
1334
case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1335
case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1336
case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1337
case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1338
case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1339
case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1341
for(y=0; y<s->mb_height; y++){
1342
for(x=0; x<s->mb_width; x++){
1343
if(s->avctx->debug&FF_DEBUG_SKIP){
1344
int count= s->mbskip_table[x + y*s->mb_stride];
1345
if(count>9) count=9;
1346
av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1348
if(s->avctx->debug&FF_DEBUG_QP){
1349
av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1351
if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1352
int mb_type= pict->mb_type[x + y*s->mb_stride];
1353
//Type & MV direction
1355
av_log(s->avctx, AV_LOG_DEBUG, "P");
1356
else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1357
av_log(s->avctx, AV_LOG_DEBUG, "A");
1358
else if(IS_INTRA4x4(mb_type))
1359
av_log(s->avctx, AV_LOG_DEBUG, "i");
1360
else if(IS_INTRA16x16(mb_type))
1361
av_log(s->avctx, AV_LOG_DEBUG, "I");
1362
else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1363
av_log(s->avctx, AV_LOG_DEBUG, "d");
1364
else if(IS_DIRECT(mb_type))
1365
av_log(s->avctx, AV_LOG_DEBUG, "D");
1366
else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1367
av_log(s->avctx, AV_LOG_DEBUG, "g");
1368
else if(IS_GMC(mb_type))
1369
av_log(s->avctx, AV_LOG_DEBUG, "G");
1370
else if(IS_SKIP(mb_type))
1371
av_log(s->avctx, AV_LOG_DEBUG, "S");
1372
else if(!USES_LIST(mb_type, 1))
1373
av_log(s->avctx, AV_LOG_DEBUG, ">");
1374
else if(!USES_LIST(mb_type, 0))
1375
av_log(s->avctx, AV_LOG_DEBUG, "<");
1377
assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1378
av_log(s->avctx, AV_LOG_DEBUG, "X");
1383
av_log(s->avctx, AV_LOG_DEBUG, "+");
1384
else if(IS_16X8(mb_type))
1385
av_log(s->avctx, AV_LOG_DEBUG, "-");
1386
else if(IS_8X16(mb_type))
1387
av_log(s->avctx, AV_LOG_DEBUG, "|");
1388
else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1389
av_log(s->avctx, AV_LOG_DEBUG, " ");
1391
av_log(s->avctx, AV_LOG_DEBUG, "?");
1394
if(IS_INTERLACED(mb_type))
1395
av_log(s->avctx, AV_LOG_DEBUG, "=");
1397
av_log(s->avctx, AV_LOG_DEBUG, " ");
1399
// av_log(s->avctx, AV_LOG_DEBUG, " ");
1401
av_log(s->avctx, AV_LOG_DEBUG, "\n");
1405
if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1406
const int shift= 1 + s->quarter_sample;
1410
int h_chroma_shift, v_chroma_shift, block_height;
1411
const int width = s->avctx->width;
1412
const int height= s->avctx->height;
1413
const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1414
const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1415
s->low_delay=0; //needed to see the vectors without trashing the buffers
1417
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1419
memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1420
pict->data[i]= s->visualization_buffer[i];
1422
pict->type= FF_BUFFER_TYPE_COPY;
1424
block_height = 16>>v_chroma_shift;
1426
for(mb_y=0; mb_y<s->mb_height; mb_y++){
1428
for(mb_x=0; mb_x<s->mb_width; mb_x++){
1429
const int mb_index= mb_x + mb_y*s->mb_stride;
1430
if((s->avctx->debug_mv) && pict->motion_val){
1432
for(type=0; type<3; type++){
1435
case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1439
case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1443
case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1448
if(!USES_LIST(pict->mb_type[mb_index], direction))
1451
if(IS_8X8(pict->mb_type[mb_index])){
1454
int sx= mb_x*16 + 4 + 8*(i&1);
1455
int sy= mb_y*16 + 4 + 8*(i>>1);
1456
int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1457
int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1458
int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1459
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1461
}else if(IS_16X8(pict->mb_type[mb_index])){
1465
int sy=mb_y*16 + 4 + 8*i;
1466
int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1467
int mx=(pict->motion_val[direction][xy][0]>>shift);
1468
int my=(pict->motion_val[direction][xy][1]>>shift);
1470
if(IS_INTERLACED(pict->mb_type[mb_index]))
1473
draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1475
}else if(IS_8X16(pict->mb_type[mb_index])){
1478
int sx=mb_x*16 + 4 + 8*i;
1480
int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1481
int mx=(pict->motion_val[direction][xy][0]>>shift);
1482
int my=(pict->motion_val[direction][xy][1]>>shift);
1484
if(IS_INTERLACED(pict->mb_type[mb_index]))
1487
draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1490
int sx= mb_x*16 + 8;
1491
int sy= mb_y*16 + 8;
1492
int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1493
int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1494
int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1495
draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1499
if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1500
uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1502
for(y=0; y<block_height; y++){
1503
*(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1504
*(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1507
if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1508
int mb_type= pict->mb_type[mb_index];
1511
#define COLOR(theta, r)\
1512
u= (int)(128 + r*cos(theta*3.141592/180));\
1513
v= (int)(128 + r*sin(theta*3.141592/180));
1517
if(IS_PCM(mb_type)){
1519
}else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1521
}else if(IS_INTRA4x4(mb_type)){
1523
}else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1525
}else if(IS_DIRECT(mb_type)){
1527
}else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1529
}else if(IS_GMC(mb_type)){
1531
}else if(IS_SKIP(mb_type)){
1533
}else if(!USES_LIST(mb_type, 1)){
1535
}else if(!USES_LIST(mb_type, 0)){
1538
assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1542
u*= 0x0101010101010101ULL;
1543
v*= 0x0101010101010101ULL;
1544
for(y=0; y<block_height; y++){
1545
*(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1546
*(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1550
if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1551
*(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1552
*(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1554
if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1556
pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1558
if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1559
int dm= 1 << (mv_sample_log2-2);
1561
int sx= mb_x*16 + 8*(i&1);
1562
int sy= mb_y*16 + 8*(i>>1);
1563
int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1565
int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1566
if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1568
pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1569
if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1570
*(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1574
if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1578
s->mbskip_table[mb_index]=0;
1584
static inline int hpel_motion_lowres(MpegEncContext *s,
1585
uint8_t *dest, uint8_t *src,
1586
int field_based, int field_select,
1587
int src_x, int src_y,
1588
int width, int height, int stride,
1589
int h_edge_pos, int v_edge_pos,
1590
int w, int h, h264_chroma_mc_func *pix_op,
1591
int motion_x, int motion_y)
1593
const int lowres= s->avctx->lowres;
1594
const int op_index= FFMIN(lowres, 2);
1595
const int s_mask= (2<<lowres)-1;
1599
if(s->quarter_sample){
1604
sx= motion_x & s_mask;
1605
sy= motion_y & s_mask;
1606
src_x += motion_x >> (lowres+1);
1607
src_y += motion_y >> (lowres+1);
1609
src += src_y * stride + src_x;
1611
if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1612
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1613
s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1614
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1615
src= s->edge_emu_buffer;
1619
sx= (sx << 2) >> lowres;
1620
sy= (sy << 2) >> lowres;
1623
pix_op[op_index](dest, src, stride, h, sx, sy);
1627
/* apply one mpeg motion vector to the three components */
1628
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1629
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1630
int field_based, int bottom_field, int field_select,
1631
uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1632
int motion_x, int motion_y, int h, int mb_y)
1634
uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1635
int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1636
const int lowres= s->avctx->lowres;
1637
const int op_index= FFMIN(lowres, 2);
1638
const int block_s= 8>>lowres;
1639
const int s_mask= (2<<lowres)-1;
1640
const int h_edge_pos = s->h_edge_pos >> lowres;
1641
const int v_edge_pos = s->v_edge_pos >> lowres;
1642
linesize = s->current_picture.linesize[0] << field_based;
1643
uvlinesize = s->current_picture.linesize[1] << field_based;
1645
if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1651
motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1654
sx= motion_x & s_mask;
1655
sy= motion_y & s_mask;
1656
src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1657
src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1659
if (s->out_format == FMT_H263) {
1660
uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1661
uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1664
}else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1667
uvsx = (2*mx) & s_mask;
1668
uvsy = (2*my) & s_mask;
1669
uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1670
uvsrc_y = mb_y*block_s + (my >> lowres);
1676
uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1677
uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1680
ptr_y = ref_picture[0] + src_y * linesize + src_x;
1681
ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1682
ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1684
if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1685
|| (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1686
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1687
src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1688
ptr_y = s->edge_emu_buffer;
1689
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1690
uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1691
s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1692
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1693
s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1694
uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1700
if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1701
dest_y += s->linesize;
1702
dest_cb+= s->uvlinesize;
1703
dest_cr+= s->uvlinesize;
1707
ptr_y += s->linesize;
1708
ptr_cb+= s->uvlinesize;
1709
ptr_cr+= s->uvlinesize;
1712
sx= (sx << 2) >> lowres;
1713
sy= (sy << 2) >> lowres;
1714
pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1716
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1717
uvsx= (uvsx << 2) >> lowres;
1718
uvsy= (uvsy << 2) >> lowres;
1719
pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1720
pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1722
//FIXME h261 lowres loop filter
1725
static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1726
uint8_t *dest_cb, uint8_t *dest_cr,
1727
uint8_t **ref_picture,
1728
h264_chroma_mc_func *pix_op,
1730
const int lowres= s->avctx->lowres;
1731
const int op_index= FFMIN(lowres, 2);
1732
const int block_s= 8>>lowres;
1733
const int s_mask= (2<<lowres)-1;
1734
const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1735
const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1736
int emu=0, src_x, src_y, offset, sx, sy;
1739
if(s->quarter_sample){
1744
/* In case of 8X8, we construct a single chroma motion vector
1745
with a special rounding */
1746
mx= ff_h263_round_chroma(mx);
1747
my= ff_h263_round_chroma(my);
1751
src_x = s->mb_x*block_s + (mx >> (lowres+1));
1752
src_y = s->mb_y*block_s + (my >> (lowres+1));
1754
offset = src_y * s->uvlinesize + src_x;
1755
ptr = ref_picture[1] + offset;
1756
if(s->flags&CODEC_FLAG_EMU_EDGE){
1757
if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1758
|| (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1759
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1760
ptr= s->edge_emu_buffer;
1764
sx= (sx << 2) >> lowres;
1765
sy= (sy << 2) >> lowres;
1766
pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1768
ptr = ref_picture[2] + offset;
1770
s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1771
ptr= s->edge_emu_buffer;
1773
pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1777
* motion compensation of a single macroblock
1779
* @param dest_y luma destination pointer
1780
* @param dest_cb chroma cb/u destination pointer
1781
* @param dest_cr chroma cr/v destination pointer
1782
* @param dir direction (0->forward, 1->backward)
1783
* @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1784
* @param pix_op halfpel motion compensation function (average or put normally)
1785
* the motion vectors are taken from s->mv and the MV type from s->mv_type
1787
static inline void MPV_motion_lowres(MpegEncContext *s,
1788
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1789
int dir, uint8_t **ref_picture,
1790
h264_chroma_mc_func *pix_op)
1794
const int lowres= s->avctx->lowres;
1795
const int block_s= 8>>lowres;
1800
switch(s->mv_type) {
1802
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1804
ref_picture, pix_op,
1805
s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1811
hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1812
ref_picture[0], 0, 0,
1813
(2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1814
s->width, s->height, s->linesize,
1815
s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1816
block_s, block_s, pix_op,
1817
s->mv[dir][i][0], s->mv[dir][i][1]);
1819
mx += s->mv[dir][i][0];
1820
my += s->mv[dir][i][1];
1823
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1824
chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1827
if (s->picture_structure == PICT_FRAME) {
1829
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1830
1, 0, s->field_select[dir][0],
1831
ref_picture, pix_op,
1832
s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1834
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1835
1, 1, s->field_select[dir][1],
1836
ref_picture, pix_op,
1837
s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1839
if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1840
ref_picture= s->current_picture_ptr->data;
1843
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1844
0, 0, s->field_select[dir][0],
1845
ref_picture, pix_op,
1846
s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1851
uint8_t ** ref2picture;
1853
if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1854
ref2picture= ref_picture;
1856
ref2picture= s->current_picture_ptr->data;
1859
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1860
0, 0, s->field_select[dir][i],
1861
ref2picture, pix_op,
1862
s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1864
dest_y += 2*block_s*s->linesize;
1865
dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1866
dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1870
if(s->picture_structure == PICT_FRAME){
1874
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1876
ref_picture, pix_op,
1877
s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1879
pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1883
mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1884
0, 0, s->picture_structure != i+1,
1885
ref_picture, pix_op,
1886
s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1888
// after put we make avg of the same block
1889
pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1891
//opposite parity is always in the same frame if this is second field
1892
if(!s->first_field){
1893
ref_picture = s->current_picture_ptr->data;
1903
* find the lowest MB row referenced in the MVs
1905
int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1907
int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1908
int my, off, i, mvs;
1910
if (s->picture_structure != PICT_FRAME) goto unhandled;
1912
switch (s->mv_type) {
1926
for (i = 0; i < mvs; i++) {
1927
my = s->mv[dir][i][1]<<qpel_shift;
1928
my_max = FFMAX(my_max, my);
1929
my_min = FFMIN(my_min, my);
1932
off = (FFMAX(-my_min, my_max) + 63) >> 6;
1934
return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1936
return s->mb_height-1;
1939
/* put block[] to dest[] */
1940
static inline void put_dct(MpegEncContext *s,
1941
DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1943
s->dct_unquantize_intra(s, block, i, qscale);
1944
s->dsp.idct_put (dest, line_size, block);
1947
/* add block[] to dest[] */
1948
static inline void add_dct(MpegEncContext *s,
1949
DCTELEM *block, int i, uint8_t *dest, int line_size)
1951
if (s->block_last_index[i] >= 0) {
1952
s->dsp.idct_add (dest, line_size, block);
1956
static inline void add_dequant_dct(MpegEncContext *s,
1957
DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1959
if (s->block_last_index[i] >= 0) {
1960
s->dct_unquantize_inter(s, block, i, qscale);
1962
s->dsp.idct_add (dest, line_size, block);
1967
* cleans dc, ac, coded_block for the current non intra MB
1969
void ff_clean_intra_table_entries(MpegEncContext *s)
1971
int wrap = s->b8_stride;
1972
int xy = s->block_index[0];
1975
s->dc_val[0][xy + 1 ] =
1976
s->dc_val[0][xy + wrap] =
1977
s->dc_val[0][xy + 1 + wrap] = 1024;
1979
memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1980
memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1981
if (s->msmpeg4_version>=3) {
1982
s->coded_block[xy ] =
1983
s->coded_block[xy + 1 ] =
1984
s->coded_block[xy + wrap] =
1985
s->coded_block[xy + 1 + wrap] = 0;
1988
wrap = s->mb_stride;
1989
xy = s->mb_x + s->mb_y * wrap;
1991
s->dc_val[2][xy] = 1024;
1993
memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1994
memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1996
s->mbintra_table[xy]= 0;
1999
/* generic function called after a macroblock has been parsed by the
2000
decoder or after it has been encoded by the encoder.
2002
Important variables used:
2003
s->mb_intra : true if intra macroblock
2004
s->mv_dir : motion vector direction
2005
s->mv_type : motion vector type
2006
s->mv : motion vector
2007
s->interlaced_dct : true if interlaced dct used (mpeg2)
2009
static av_always_inline
2010
void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2011
int lowres_flag, int is_mpeg12)
2013
const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2014
if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2015
ff_xvmc_decode_mb(s);//xvmc uses pblocks
2019
if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2020
/* save DCT coefficients */
2022
DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
2023
av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2025
for(j=0; j<64; j++){
2026
*dct++ = block[i][s->dsp.idct_permutation[j]];
2027
av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2029
av_log(s->avctx, AV_LOG_DEBUG, "\n");
2033
s->current_picture.qscale_table[mb_xy]= s->qscale;
2035
/* update DC predictors for P macroblocks */
2037
if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2038
if(s->mbintra_table[mb_xy])
2039
ff_clean_intra_table_entries(s);
2043
s->last_dc[2] = 128 << s->intra_dc_precision;
2046
else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2047
s->mbintra_table[mb_xy]=1;
2049
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
2050
uint8_t *dest_y, *dest_cb, *dest_cr;
2051
int dct_linesize, dct_offset;
2052
op_pixels_func (*op_pix)[4];
2053
qpel_mc_func (*op_qpix)[16];
2054
const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2055
const int uvlinesize= s->current_picture.linesize[1];
2056
const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2057
const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2059
/* avoid copy if macroblock skipped in last frame too */
2060
/* skip only during decoding as we might trash the buffers during encoding a bit */
2062
uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2063
const int age= s->current_picture.age;
2067
if (s->mb_skipped) {
2069
assert(s->pict_type!=AV_PICTURE_TYPE_I);
2071
(*mbskip_ptr) ++; /* indicate that this time we skipped it */
2072
if(*mbskip_ptr >99) *mbskip_ptr= 99;
2074
/* if previous was skipped too, then nothing to do ! */
2075
if (*mbskip_ptr >= age && s->current_picture.reference){
2078
} else if(!s->current_picture.reference){
2079
(*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2080
if(*mbskip_ptr >99) *mbskip_ptr= 99;
2082
*mbskip_ptr = 0; /* not skipped */
2086
dct_linesize = linesize << s->interlaced_dct;
2087
dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2091
dest_cb= s->dest[1];
2092
dest_cr= s->dest[2];
2094
dest_y = s->b_scratchpad;
2095
dest_cb= s->b_scratchpad+16*linesize;
2096
dest_cr= s->b_scratchpad+32*linesize;
2100
/* motion handling */
2101
/* decoding or more than one mb_type (MC was already done otherwise) */
2104
if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2105
if (s->mv_dir & MV_DIR_FORWARD) {
2106
ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2108
if (s->mv_dir & MV_DIR_BACKWARD) {
2109
ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2114
h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2116
if (s->mv_dir & MV_DIR_FORWARD) {
2117
MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
2118
op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2120
if (s->mv_dir & MV_DIR_BACKWARD) {
2121
MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
2124
op_qpix= s->me.qpel_put;
2125
if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2126
op_pix = s->dsp.put_pixels_tab;
2128
op_pix = s->dsp.put_no_rnd_pixels_tab;
2130
if (s->mv_dir & MV_DIR_FORWARD) {
2131
MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2132
op_pix = s->dsp.avg_pixels_tab;
2133
op_qpix= s->me.qpel_avg;
2135
if (s->mv_dir & MV_DIR_BACKWARD) {
2136
MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2141
/* skip dequant / idct if we are really late ;) */
2142
if(s->avctx->skip_idct){
2143
if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2144
||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2145
|| s->avctx->skip_idct >= AVDISCARD_ALL)
2149
/* add dct residue */
2150
if(s->encoding || !( s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2151
|| (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2152
add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2153
add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2154
add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2155
add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2157
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2158
if (s->chroma_y_shift){
2159
add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2160
add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2164
add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2165
add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2166
add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2167
add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2170
} else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2171
add_dct(s, block[0], 0, dest_y , dct_linesize);
2172
add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2173
add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2174
add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2176
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2177
if(s->chroma_y_shift){//Chroma420
2178
add_dct(s, block[4], 4, dest_cb, uvlinesize);
2179
add_dct(s, block[5], 5, dest_cr, uvlinesize);
2182
dct_linesize = uvlinesize << s->interlaced_dct;
2183
dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2185
add_dct(s, block[4], 4, dest_cb, dct_linesize);
2186
add_dct(s, block[5], 5, dest_cr, dct_linesize);
2187
add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2188
add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2189
if(!s->chroma_x_shift){//Chroma444
2190
add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2191
add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2192
add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2193
add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2198
else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2199
ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2202
/* dct only in intra block */
2203
if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2204
put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2205
put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2206
put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2207
put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2209
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2210
if(s->chroma_y_shift){
2211
put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2212
put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2216
put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2217
put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2218
put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2219
put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2223
s->dsp.idct_put(dest_y , dct_linesize, block[0]);
2224
s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2225
s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2226
s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2228
if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2229
if(s->chroma_y_shift){
2230
s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2231
s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2234
dct_linesize = uvlinesize << s->interlaced_dct;
2235
dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2237
s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2238
s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2239
s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2240
s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2241
if(!s->chroma_x_shift){//Chroma444
2242
s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2243
s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2244
s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2245
s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2253
s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2254
s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2255
s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2260
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2262
if(s->out_format == FMT_MPEG1) {
2263
if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2264
else MPV_decode_mb_internal(s, block, 0, 1);
2267
if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2268
else MPV_decode_mb_internal(s, block, 0, 0);
2273
* @param h is the normal height, this will be reduced automatically if needed for the last row
2275
void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2276
const int field_pic= s->picture_structure != PICT_FRAME;
2282
if (!s->avctx->hwaccel
2283
&& !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2284
&& s->unrestricted_mv
2285
&& s->current_picture.reference
2287
&& !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2288
int sides = 0, edge_h;
2289
int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2290
int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2291
if (y==0) sides |= EDGE_TOP;
2292
if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2294
edge_h= FFMIN(h, s->v_edge_pos - y);
2296
s->dsp.draw_edges(s->current_picture_ptr->data[0] + y *s->linesize , s->linesize,
2297
s->h_edge_pos , edge_h , EDGE_WIDTH , EDGE_WIDTH , sides);
2298
s->dsp.draw_edges(s->current_picture_ptr->data[1] + (y>>vshift)*s->uvlinesize, s->uvlinesize,
2299
s->h_edge_pos>>hshift, edge_h>>hshift, EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2300
s->dsp.draw_edges(s->current_picture_ptr->data[2] + (y>>vshift)*s->uvlinesize, s->uvlinesize,
2301
s->h_edge_pos>>hshift, edge_h>>hshift, EDGE_WIDTH>>hshift, EDGE_WIDTH>>vshift, sides);
2304
h= FFMIN(h, s->avctx->height - y);
2306
if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2308
if (s->avctx->draw_horiz_band) {
2312
if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2313
src= (AVFrame*)s->current_picture_ptr;
2314
else if(s->last_picture_ptr)
2315
src= (AVFrame*)s->last_picture_ptr;
2319
if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2325
offset[0]= y * s->linesize;
2327
offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2333
s->avctx->draw_horiz_band(s->avctx, src, offset,
2334
y, s->picture_structure, h);
2338
void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2339
const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2340
const int uvlinesize= s->current_picture.linesize[1];
2341
const int mb_size= 4 - s->avctx->lowres;
2343
s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2344
s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2345
s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2346
s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2347
s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2348
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;
2349
//block_index is not used by mpeg2, so it is not affected by chroma_format
2351
s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2352
s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2353
s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2355
if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2357
if(s->picture_structure==PICT_FRAME){
2358
s->dest[0] += s->mb_y * linesize << mb_size;
2359
s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2360
s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2362
s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2363
s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2364
s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2365
assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2370
void ff_mpeg_flush(AVCodecContext *avctx){
2372
MpegEncContext *s = avctx->priv_data;
2374
if(s==NULL || s->picture==NULL)
2377
for(i=0; i<s->picture_count; i++){
2378
if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2379
|| s->picture[i].type == FF_BUFFER_TYPE_USER))
2380
free_frame_buffer(s, &s->picture[i]);
2382
s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2384
s->mb_x= s->mb_y= 0;
2387
s->parse_context.state= -1;
2388
s->parse_context.frame_start_found= 0;
2389
s->parse_context.overread= 0;
2390
s->parse_context.overread_index= 0;
2391
s->parse_context.index= 0;
2392
s->parse_context.last_index= 0;
2393
s->bitstream_buffer_size=0;
2397
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2398
DCTELEM *block, int n, int qscale)
2400
int i, level, nCoeffs;
2401
const uint16_t *quant_matrix;
2403
nCoeffs= s->block_last_index[n];
2406
block[0] = block[0] * s->y_dc_scale;
2408
block[0] = block[0] * s->c_dc_scale;
2409
/* XXX: only mpeg1 */
2410
quant_matrix = s->intra_matrix;
2411
for(i=1;i<=nCoeffs;i++) {
2412
int j= s->intra_scantable.permutated[i];
2417
level = (int)(level * qscale * quant_matrix[j]) >> 3;
2418
level = (level - 1) | 1;
2421
level = (int)(level * qscale * quant_matrix[j]) >> 3;
2422
level = (level - 1) | 1;
2429
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2430
DCTELEM *block, int n, int qscale)
2432
int i, level, nCoeffs;
2433
const uint16_t *quant_matrix;
2435
nCoeffs= s->block_last_index[n];
2437
quant_matrix = s->inter_matrix;
2438
for(i=0; i<=nCoeffs; i++) {
2439
int j= s->intra_scantable.permutated[i];
2444
level = (((level << 1) + 1) * qscale *
2445
((int) (quant_matrix[j]))) >> 4;
2446
level = (level - 1) | 1;
2449
level = (((level << 1) + 1) * qscale *
2450
((int) (quant_matrix[j]))) >> 4;
2451
level = (level - 1) | 1;
2458
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2459
DCTELEM *block, int n, int qscale)
2461
int i, level, nCoeffs;
2462
const uint16_t *quant_matrix;
2464
if(s->alternate_scan) nCoeffs= 63;
2465
else nCoeffs= s->block_last_index[n];
2468
block[0] = block[0] * s->y_dc_scale;
2470
block[0] = block[0] * s->c_dc_scale;
2471
quant_matrix = s->intra_matrix;
2472
for(i=1;i<=nCoeffs;i++) {
2473
int j= s->intra_scantable.permutated[i];
2478
level = (int)(level * qscale * quant_matrix[j]) >> 3;
2481
level = (int)(level * qscale * quant_matrix[j]) >> 3;
2488
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2489
DCTELEM *block, int n, int qscale)
2491
int i, level, nCoeffs;
2492
const uint16_t *quant_matrix;
2495
if(s->alternate_scan) nCoeffs= 63;
2496
else nCoeffs= s->block_last_index[n];
2499
block[0] = block[0] * s->y_dc_scale;
2501
block[0] = block[0] * s->c_dc_scale;
2502
quant_matrix = s->intra_matrix;
2503
for(i=1;i<=nCoeffs;i++) {
2504
int j= s->intra_scantable.permutated[i];
2509
level = (int)(level * qscale * quant_matrix[j]) >> 3;
2512
level = (int)(level * qscale * quant_matrix[j]) >> 3;
2521
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2522
DCTELEM *block, int n, int qscale)
2524
int i, level, nCoeffs;
2525
const uint16_t *quant_matrix;
2528
if(s->alternate_scan) nCoeffs= 63;
2529
else nCoeffs= s->block_last_index[n];
2531
quant_matrix = s->inter_matrix;
2532
for(i=0; i<=nCoeffs; i++) {
2533
int j= s->intra_scantable.permutated[i];
2538
level = (((level << 1) + 1) * qscale *
2539
((int) (quant_matrix[j]))) >> 4;
2542
level = (((level << 1) + 1) * qscale *
2543
((int) (quant_matrix[j]))) >> 4;
2552
static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2553
DCTELEM *block, int n, int qscale)
2555
int i, level, qmul, qadd;
2558
assert(s->block_last_index[n]>=0);
2564
block[0] = block[0] * s->y_dc_scale;
2566
block[0] = block[0] * s->c_dc_scale;
2567
qadd = (qscale - 1) | 1;
2574
nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2576
for(i=1; i<=nCoeffs; i++) {
2580
level = level * qmul - qadd;
2582
level = level * qmul + qadd;
2589
static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2590
DCTELEM *block, int n, int qscale)
2592
int i, level, qmul, qadd;
2595
assert(s->block_last_index[n]>=0);
2597
qadd = (qscale - 1) | 1;
2600
nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2602
for(i=0; i<=nCoeffs; i++) {
2606
level = level * qmul - qadd;
2608
level = level * qmul + qadd;
2616
* set qscale and update qscale dependent variables.
2618
void ff_set_qscale(MpegEncContext * s, int qscale)
2622
else if (qscale > 31)
2626
s->chroma_qscale= s->chroma_qscale_table[qscale];
2628
s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2629
s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2632
void MPV_report_decode_progress(MpegEncContext *s)
2634
if (s->pict_type != FF_B_TYPE && !s->partitioned_frame && !s->error_occurred)
2635
ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
added
removed
.pc/post-0.7.1/0007-H.264-fix-overreads-of-qscale_table.patch/libavcodec/mpegvideo.c
