FFmpeg
mpegvideo.c
Go to the documentation of this file.
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
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.
14  *
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.
19  *
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
23  */
24 
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
36 
37 #include "avcodec.h"
38 #include "blockdsp.h"
39 #include "h264chroma.h"
40 #include "idctdsp.h"
41 #include "internal.h"
42 #include "mathops.h"
43 #include "mpeg_er.h"
44 #include "mpegutils.h"
45 #include "mpegvideo.h"
46 #include "mpegvideodata.h"
47 #include "mjpegenc.h"
48 #include "msmpeg4.h"
49 #include "qpeldsp.h"
50 #include "thread.h"
51 #include "wmv2.h"
52 #include <limits.h>
53 
55  int16_t *block, int n, int qscale)
56 {
57  int i, level, nCoeffs;
58  const uint16_t *quant_matrix;
59 
60  nCoeffs= s->block_last_index[n];
61 
62  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
63  /* XXX: only MPEG-1 */
64  quant_matrix = s->intra_matrix;
65  for(i=1;i<=nCoeffs;i++) {
66  int j= s->intra_scantable.permutated[i];
67  level = block[j];
68  if (level) {
69  if (level < 0) {
70  level = -level;
71  level = (int)(level * qscale * quant_matrix[j]) >> 3;
72  level = (level - 1) | 1;
73  level = -level;
74  } else {
75  level = (int)(level * qscale * quant_matrix[j]) >> 3;
76  level = (level - 1) | 1;
77  }
78  block[j] = level;
79  }
80  }
81 }
82 
84  int16_t *block, int n, int qscale)
85 {
86  int i, level, nCoeffs;
87  const uint16_t *quant_matrix;
88 
89  nCoeffs= s->block_last_index[n];
90 
91  quant_matrix = s->inter_matrix;
92  for(i=0; i<=nCoeffs; i++) {
93  int j= s->intra_scantable.permutated[i];
94  level = block[j];
95  if (level) {
96  if (level < 0) {
97  level = -level;
98  level = (((level << 1) + 1) * qscale *
99  ((int) (quant_matrix[j]))) >> 4;
100  level = (level - 1) | 1;
101  level = -level;
102  } else {
103  level = (((level << 1) + 1) * qscale *
104  ((int) (quant_matrix[j]))) >> 4;
105  level = (level - 1) | 1;
106  }
107  block[j] = level;
108  }
109  }
110 }
111 
113  int16_t *block, int n, int qscale)
114 {
115  int i, level, nCoeffs;
116  const uint16_t *quant_matrix;
117 
118  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
119  else qscale <<= 1;
120 
121  if(s->alternate_scan) nCoeffs= 63;
122  else nCoeffs= s->block_last_index[n];
123 
124  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
125  quant_matrix = s->intra_matrix;
126  for(i=1;i<=nCoeffs;i++) {
127  int j= s->intra_scantable.permutated[i];
128  level = block[j];
129  if (level) {
130  if (level < 0) {
131  level = -level;
132  level = (int)(level * qscale * quant_matrix[j]) >> 4;
133  level = -level;
134  } else {
135  level = (int)(level * qscale * quant_matrix[j]) >> 4;
136  }
137  block[j] = level;
138  }
139  }
140 }
141 
143  int16_t *block, int n, int qscale)
144 {
145  int i, level, nCoeffs;
146  const uint16_t *quant_matrix;
147  int sum=-1;
148 
149  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
150  else qscale <<= 1;
151 
152  if(s->alternate_scan) nCoeffs= 63;
153  else nCoeffs= s->block_last_index[n];
154 
155  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
156  sum += block[0];
157  quant_matrix = s->intra_matrix;
158  for(i=1;i<=nCoeffs;i++) {
159  int j= s->intra_scantable.permutated[i];
160  level = block[j];
161  if (level) {
162  if (level < 0) {
163  level = -level;
164  level = (int)(level * qscale * quant_matrix[j]) >> 4;
165  level = -level;
166  } else {
167  level = (int)(level * qscale * quant_matrix[j]) >> 4;
168  }
169  block[j] = level;
170  sum+=level;
171  }
172  }
173  block[63]^=sum&1;
174 }
175 
177  int16_t *block, int n, int qscale)
178 {
179  int i, level, nCoeffs;
180  const uint16_t *quant_matrix;
181  int sum=-1;
182 
183  if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
184  else qscale <<= 1;
185 
186  if(s->alternate_scan) nCoeffs= 63;
187  else nCoeffs= s->block_last_index[n];
188 
189  quant_matrix = s->inter_matrix;
190  for(i=0; i<=nCoeffs; i++) {
191  int j= s->intra_scantable.permutated[i];
192  level = block[j];
193  if (level) {
194  if (level < 0) {
195  level = -level;
196  level = (((level << 1) + 1) * qscale *
197  ((int) (quant_matrix[j]))) >> 5;
198  level = -level;
199  } else {
200  level = (((level << 1) + 1) * qscale *
201  ((int) (quant_matrix[j]))) >> 5;
202  }
203  block[j] = level;
204  sum+=level;
205  }
206  }
207  block[63]^=sum&1;
208 }
209 
211  int16_t *block, int n, int qscale)
212 {
213  int i, level, qmul, qadd;
214  int nCoeffs;
215 
216  av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
217 
218  qmul = qscale << 1;
219 
220  if (!s->h263_aic) {
221  block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
222  qadd = (qscale - 1) | 1;
223  }else{
224  qadd = 0;
225  }
226  if(s->ac_pred)
227  nCoeffs=63;
228  else
229  nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
230 
231  for(i=1; i<=nCoeffs; i++) {
232  level = block[i];
233  if (level) {
234  if (level < 0) {
235  level = level * qmul - qadd;
236  } else {
237  level = level * qmul + qadd;
238  }
239  block[i] = level;
240  }
241  }
242 }
243 
245  int16_t *block, int n, int qscale)
246 {
247  int i, level, qmul, qadd;
248  int nCoeffs;
249 
250  av_assert2(s->block_last_index[n]>=0);
251 
252  qadd = (qscale - 1) | 1;
253  qmul = qscale << 1;
254 
255  nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
256 
257  for(i=0; i<=nCoeffs; i++) {
258  level = block[i];
259  if (level) {
260  if (level < 0) {
261  level = level * qmul - qadd;
262  } else {
263  level = level * qmul + qadd;
264  }
265  block[i] = level;
266  }
267  }
268 }
269 
270 
271 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
272 {
273  while(h--)
274  memset(dst + h*linesize, 128, 16);
275 }
276 
277 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
278 {
279  while(h--)
280  memset(dst + h*linesize, 128, 8);
281 }
282 
283 /* init common dct for both encoder and decoder */
285 {
286  ff_blockdsp_init(&s->bdsp, s->avctx);
287  ff_h264chroma_init(&s->h264chroma, 8); //for lowres
288  ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
289  ff_mpegvideodsp_init(&s->mdsp);
290  ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
291 
292  if (s->avctx->debug & FF_DEBUG_NOMC) {
293  int i;
294  for (i=0; i<4; i++) {
295  s->hdsp.avg_pixels_tab[0][i] = gray16;
296  s->hdsp.put_pixels_tab[0][i] = gray16;
297  s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
298 
299  s->hdsp.avg_pixels_tab[1][i] = gray8;
300  s->hdsp.put_pixels_tab[1][i] = gray8;
301  s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
302  }
303  }
304 
305  s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
306  s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
307  s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
308  s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
309  s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
310  if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
311  s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
312  s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
313 
314  if (HAVE_INTRINSICS_NEON)
316 
317  if (ARCH_ALPHA)
319  if (ARCH_ARM)
321  if (ARCH_PPC)
323  if (ARCH_X86)
325  if (ARCH_MIPS)
327 
328  return 0;
329 }
330 
332 {
333  if (s->codec_id == AV_CODEC_ID_MPEG4)
334  s->idsp.mpeg4_studio_profile = s->studio_profile;
335  ff_idctdsp_init(&s->idsp, s->avctx);
336 
337  /* load & permutate scantables
338  * note: only wmv uses different ones
339  */
340  if (s->alternate_scan) {
341  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
342  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
343  } else {
344  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
345  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
346  }
347  ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
348  ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
349 }
350 
352 {
353  return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, 0, 0,
354  s->chroma_x_shift, s->chroma_y_shift, s->out_format,
355  s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
356  &s->linesize, &s->uvlinesize);
357 }
358 
360 {
361  int y_size = s->b8_stride * (2 * s->mb_height + 1);
362  int c_size = s->mb_stride * (s->mb_height + 1);
363  int yc_size = y_size + 2 * c_size;
364  int i;
365 
366  if (s->mb_height & 1)
367  yc_size += 2*s->b8_stride + 2*s->mb_stride;
368 
369  if (s->encoding) {
370  if (!FF_ALLOCZ_TYPED_ARRAY(s->me.map, ME_MAP_SIZE) ||
371  !FF_ALLOCZ_TYPED_ARRAY(s->me.score_map, ME_MAP_SIZE))
372  return AVERROR(ENOMEM);
373 
374  if (s->noise_reduction) {
375  if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_error_sum, 2))
376  return AVERROR(ENOMEM);
377  }
378  }
379  if (!FF_ALLOCZ_TYPED_ARRAY(s->blocks, 2))
380  return AVERROR(ENOMEM);
381  s->block = s->blocks[0];
382 
383  for (i = 0; i < 12; i++) {
384  s->pblocks[i] = &s->block[i];
385  }
386 
387  if (!(s->block32 = av_mallocz(sizeof(*s->block32))) ||
388  !(s->dpcm_macroblock = av_mallocz(sizeof(*s->dpcm_macroblock))))
389  return AVERROR(ENOMEM);
390  s->dpcm_direction = 0;
391 
392  if (s->avctx->codec_tag == AV_RL32("VCR2")) {
393  // exchange uv
394  FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
395  }
396 
397  if (s->out_format == FMT_H263) {
398  /* ac values */
399  if (!FF_ALLOCZ_TYPED_ARRAY(s->ac_val_base, yc_size))
400  return AVERROR(ENOMEM);
401  s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
402  s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
403  s->ac_val[2] = s->ac_val[1] + c_size;
404  }
405 
406  return 0;
407 }
408 
409 /**
410  * Initialize an MpegEncContext's thread contexts. Presumes that
411  * slice_context_count is already set and that all the fields
412  * that are freed/reset in free_duplicate_context() are NULL.
413  */
415 {
416  int nb_slices = s->slice_context_count, ret;
417 
418  /* We initialize the copies before the original so that
419  * fields allocated in init_duplicate_context are NULL after
420  * copying. This prevents double-frees upon allocation error. */
421  for (int i = 1; i < nb_slices; i++) {
422  s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
423  if (!s->thread_context[i])
424  return AVERROR(ENOMEM);
425  if ((ret = init_duplicate_context(s->thread_context[i])) < 0)
426  return ret;
427  s->thread_context[i]->start_mb_y =
428  (s->mb_height * (i ) + nb_slices / 2) / nb_slices;
429  s->thread_context[i]->end_mb_y =
430  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
431  }
432  s->start_mb_y = 0;
433  s->end_mb_y = nb_slices > 1 ? (s->mb_height + nb_slices / 2) / nb_slices
434  : s->mb_height;
435  return init_duplicate_context(s);
436 }
437 
439 {
440  if (!s)
441  return;
442 
443  av_freep(&s->sc.edge_emu_buffer);
444  av_freep(&s->me.scratchpad);
445  s->me.temp =
446  s->sc.rd_scratchpad =
447  s->sc.b_scratchpad =
448  s->sc.obmc_scratchpad = NULL;
449 
450  av_freep(&s->dct_error_sum);
451  av_freep(&s->me.map);
452  av_freep(&s->me.score_map);
453  av_freep(&s->blocks);
454  av_freep(&s->block32);
455  av_freep(&s->dpcm_macroblock);
456  av_freep(&s->ac_val_base);
457  s->block = NULL;
458 }
459 
461 {
462  for (int i = 1; i < s->slice_context_count; i++) {
463  free_duplicate_context(s->thread_context[i]);
464  av_freep(&s->thread_context[i]);
465  }
467 }
468 
470 {
471 #define COPY(a) bak->a = src->a
472  COPY(sc.edge_emu_buffer);
473  COPY(me.scratchpad);
474  COPY(me.temp);
475  COPY(sc.rd_scratchpad);
476  COPY(sc.b_scratchpad);
477  COPY(sc.obmc_scratchpad);
478  COPY(me.map);
479  COPY(me.score_map);
480  COPY(blocks);
481  COPY(block);
482  COPY(block32);
483  COPY(dpcm_macroblock);
484  COPY(dpcm_direction);
485  COPY(start_mb_y);
486  COPY(end_mb_y);
487  COPY(me.map_generation);
488  COPY(pb);
489  COPY(dct_error_sum);
490  COPY(dct_count[0]);
491  COPY(dct_count[1]);
492  COPY(ac_val_base);
493  COPY(ac_val[0]);
494  COPY(ac_val[1]);
495  COPY(ac_val[2]);
496 #undef COPY
497 }
498 
500 {
501  MpegEncContext bak;
502  int i, ret;
503  // FIXME copy only needed parts
504  backup_duplicate_context(&bak, dst);
505  memcpy(dst, src, sizeof(MpegEncContext));
506  backup_duplicate_context(dst, &bak);
507  for (i = 0; i < 12; i++) {
508  dst->pblocks[i] = &dst->block[i];
509  }
510  if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
511  // exchange uv
512  FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
513  }
514  if (!dst->sc.edge_emu_buffer &&
515  (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
516  &dst->sc, dst->linesize)) < 0) {
517  av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
518  "scratch buffers.\n");
519  return ret;
520  }
521  return 0;
522 }
523 
525  const AVCodecContext *src)
526 {
527  int i, ret;
528  MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
529 
530  if (dst == src)
531  return 0;
532 
533  av_assert0(s != s1);
534 
535  // FIXME can parameters change on I-frames?
536  // in that case dst may need a reinit
537  if (!s->context_initialized) {
538  int err;
539  memcpy(s, s1, sizeof(MpegEncContext));
540 
541  s->avctx = dst;
542  s->bitstream_buffer = NULL;
543  s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
544 
545  if (s1->context_initialized){
546 // s->picture_range_start += MAX_PICTURE_COUNT;
547 // s->picture_range_end += MAX_PICTURE_COUNT;
549  if((err = ff_mpv_common_init(s)) < 0){
550  memset(s, 0, sizeof(MpegEncContext));
551  s->avctx = dst;
552  return err;
553  }
554  }
555  }
556 
557  if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
558  s->height = s1->height;
559  s->width = s1->width;
561  return ret;
562  }
563 
564  s->avctx->coded_height = s1->avctx->coded_height;
565  s->avctx->coded_width = s1->avctx->coded_width;
566  s->avctx->width = s1->avctx->width;
567  s->avctx->height = s1->avctx->height;
568 
569  s->quarter_sample = s1->quarter_sample;
570 
571  s->coded_picture_number = s1->coded_picture_number;
572  s->picture_number = s1->picture_number;
573 
574  av_assert0(!s->picture || s->picture != s1->picture);
575  if(s->picture)
576  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
577  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
578  if (s1->picture && s1->picture[i].f->buf[0] &&
579  (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
580  return ret;
581  }
582 
583 #define UPDATE_PICTURE(pic)\
584 do {\
585  ff_mpeg_unref_picture(s->avctx, &s->pic);\
586  if (s1->pic.f && s1->pic.f->buf[0])\
587  ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
588  else\
589  ret = ff_update_picture_tables(&s->pic, &s1->pic);\
590  if (ret < 0)\
591  return ret;\
592 } while (0)
593 
594  UPDATE_PICTURE(current_picture);
596  UPDATE_PICTURE(next_picture);
597 
598 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
599  ((pic && pic >= old_ctx->picture && \
600  pic < old_ctx->picture + MAX_PICTURE_COUNT) ? \
601  &new_ctx->picture[pic - old_ctx->picture] : NULL)
602 
603  s->last_picture_ptr = REBASE_PICTURE(s1->last_picture_ptr, s, s1);
604  s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
605  s->next_picture_ptr = REBASE_PICTURE(s1->next_picture_ptr, s, s1);
606 
607  // Error/bug resilience
608  s->next_p_frame_damaged = s1->next_p_frame_damaged;
609  s->workaround_bugs = s1->workaround_bugs;
610  s->padding_bug_score = s1->padding_bug_score;
611 
612  // MPEG-4 timing info
613  memcpy(&s->last_time_base, &s1->last_time_base,
614  (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
615  (char *) &s1->last_time_base);
616 
617  // B-frame info
618  s->max_b_frames = s1->max_b_frames;
619  s->low_delay = s1->low_delay;
620  s->droppable = s1->droppable;
621 
622  // DivX handling (doesn't work)
623  s->divx_packed = s1->divx_packed;
624 
625  if (s1->bitstream_buffer) {
626  if (s1->bitstream_buffer_size +
627  AV_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) {
628  av_fast_malloc(&s->bitstream_buffer,
629  &s->allocated_bitstream_buffer_size,
630  s1->allocated_bitstream_buffer_size);
631  if (!s->bitstream_buffer) {
632  s->bitstream_buffer_size = 0;
633  return AVERROR(ENOMEM);
634  }
635  }
636  s->bitstream_buffer_size = s1->bitstream_buffer_size;
637  memcpy(s->bitstream_buffer, s1->bitstream_buffer,
638  s1->bitstream_buffer_size);
639  memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
641  }
642 
643  // linesize-dependent scratch buffer allocation
644  if (!s->sc.edge_emu_buffer)
645  if (s1->linesize) {
646  if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
647  &s->sc, s1->linesize) < 0) {
648  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
649  "scratch buffers.\n");
650  return AVERROR(ENOMEM);
651  }
652  } else {
653  av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
654  "be allocated due to unknown size.\n");
655  }
656 
657  // MPEG-2/interlacing info
658  memcpy(&s->progressive_sequence, &s1->progressive_sequence,
659  (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
660 
661  if (!s1->first_field) {
662  s->last_pict_type = s1->pict_type;
663  if (s1->current_picture_ptr)
664  s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
665  }
666 
667  return 0;
668 }
669 
670 /**
671  * Set the given MpegEncContext to common defaults
672  * (same for encoding and decoding).
673  * The changed fields will not depend upon the
674  * prior state of the MpegEncContext.
675  */
677 {
678  s->y_dc_scale_table =
679  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
680  s->chroma_qscale_table = ff_default_chroma_qscale_table;
681  s->progressive_frame = 1;
682  s->progressive_sequence = 1;
683  s->picture_structure = PICT_FRAME;
684 
685  s->coded_picture_number = 0;
686  s->picture_number = 0;
687 
688  s->f_code = 1;
689  s->b_code = 1;
690 
691  s->slice_context_count = 1;
692 }
693 
694 /**
695  * Initialize the given MpegEncContext for decoding.
696  * the changed fields will not depend upon
697  * the prior state of the MpegEncContext.
698  */
700 {
702 
703  s->avctx = avctx;
704  s->width = avctx->coded_width;
705  s->height = avctx->coded_height;
706  s->codec_id = avctx->codec->id;
707  s->workaround_bugs = avctx->workaround_bugs;
708 
709  /* convert fourcc to upper case */
710  s->codec_tag = avpriv_toupper4(avctx->codec_tag);
711 }
712 
713 /**
714  * Initialize and allocates MpegEncContext fields dependent on the resolution.
715  */
717 {
718  int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
719 
720  s->mb_width = (s->width + 15) / 16;
721  s->mb_stride = s->mb_width + 1;
722  s->b8_stride = s->mb_width * 2 + 1;
723  mb_array_size = s->mb_height * s->mb_stride;
724  mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
725 
726  /* set default edge pos, will be overridden
727  * in decode_header if needed */
728  s->h_edge_pos = s->mb_width * 16;
729  s->v_edge_pos = s->mb_height * 16;
730 
731  s->mb_num = s->mb_width * s->mb_height;
732 
733  s->block_wrap[0] =
734  s->block_wrap[1] =
735  s->block_wrap[2] =
736  s->block_wrap[3] = s->b8_stride;
737  s->block_wrap[4] =
738  s->block_wrap[5] = s->mb_stride;
739 
740  y_size = s->b8_stride * (2 * s->mb_height + 1);
741  c_size = s->mb_stride * (s->mb_height + 1);
742  yc_size = y_size + 2 * c_size;
743 
744  if (s->mb_height & 1)
745  yc_size += 2*s->b8_stride + 2*s->mb_stride;
746 
747  if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_index2xy, s->mb_num + 1))
748  return AVERROR(ENOMEM);
749  for (y = 0; y < s->mb_height; y++)
750  for (x = 0; x < s->mb_width; x++)
751  s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
752 
753  s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
754 
755  if (s->encoding) {
756  /* Allocate MV tables */
757  if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base, mv_table_size) ||
758  !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base, mv_table_size) ||
759  !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base, mv_table_size) ||
760  !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) ||
761  !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) ||
762  !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base, mv_table_size))
763  return AVERROR(ENOMEM);
764  s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
765  s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
766  s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
767  s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
768  s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
769  s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
770 
771  /* Allocate MB type table */
772  if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type, mb_array_size) ||
773  !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) ||
774  !FF_ALLOC_TYPED_ARRAY (s->cplx_tab, mb_array_size) ||
775  !FF_ALLOC_TYPED_ARRAY (s->bits_tab, mb_array_size))
776  return AVERROR(ENOMEM);
777  }
778 
779  if (s->codec_id == AV_CODEC_ID_MPEG4 ||
780  (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
781  /* interlaced direct mode decoding tables */
782  for (i = 0; i < 2; i++) {
783  int j, k;
784  for (j = 0; j < 2; j++) {
785  for (k = 0; k < 2; k++) {
786  if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_mv_table_base[i][j][k], mv_table_size))
787  return AVERROR(ENOMEM);
788  s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
789  s->mb_stride + 1;
790  }
791  if (!FF_ALLOCZ_TYPED_ARRAY(s->b_field_select_table [i][j], mv_table_size * 2) ||
792  !FF_ALLOCZ_TYPED_ARRAY(s->p_field_mv_table_base[i][j], mv_table_size))
793  return AVERROR(ENOMEM);
794  s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
795  }
796  if (!FF_ALLOCZ_TYPED_ARRAY(s->p_field_select_table[i], mv_table_size * 2))
797  return AVERROR(ENOMEM);
798  }
799  }
800  if (s->out_format == FMT_H263) {
801  /* cbp values, cbp, ac_pred, pred_dir */
802  if (!FF_ALLOCZ_TYPED_ARRAY(s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride) ||
803  !FF_ALLOCZ_TYPED_ARRAY(s->cbp_table, mb_array_size) ||
804  !FF_ALLOCZ_TYPED_ARRAY(s->pred_dir_table, mb_array_size))
805  return AVERROR(ENOMEM);
806  s->coded_block = s->coded_block_base + s->b8_stride + 1;
807  }
808 
809  if (s->h263_pred || s->h263_plus || !s->encoding) {
810  /* dc values */
811  // MN: we need these for error resilience of intra-frames
812  if (!FF_ALLOCZ_TYPED_ARRAY(s->dc_val_base, yc_size))
813  return AVERROR(ENOMEM);
814  s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
815  s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
816  s->dc_val[2] = s->dc_val[1] + c_size;
817  for (i = 0; i < yc_size; i++)
818  s->dc_val_base[i] = 1024;
819  }
820 
821  /* which mb is an intra block, init macroblock skip table */
822  if (!FF_ALLOC_TYPED_ARRAY(s->mbintra_table, mb_array_size) ||
823  // Note the + 1 is for a quicker MPEG-4 slice_end detection
824  !FF_ALLOCZ_TYPED_ARRAY(s->mbskip_table, mb_array_size + 2))
825  return AVERROR(ENOMEM);
826  memset(s->mbintra_table, 1, mb_array_size);
827 
828  return ff_mpeg_er_init(s);
829 }
830 
832 {
833  int i, j, k;
834 
835  memset(&s->next_picture, 0, sizeof(s->next_picture));
836  memset(&s->last_picture, 0, sizeof(s->last_picture));
837  memset(&s->current_picture, 0, sizeof(s->current_picture));
838  memset(&s->new_picture, 0, sizeof(s->new_picture));
839 
840  memset(s->thread_context, 0, sizeof(s->thread_context));
841 
842  s->me.map = NULL;
843  s->me.score_map = NULL;
844  s->dct_error_sum = NULL;
845  s->block = NULL;
846  s->blocks = NULL;
847  s->block32 = NULL;
848  memset(s->pblocks, 0, sizeof(s->pblocks));
849  s->dpcm_direction = 0;
850  s->dpcm_macroblock = NULL;
851  s->ac_val_base = NULL;
852  s->ac_val[0] =
853  s->ac_val[1] =
854  s->ac_val[2] =NULL;
855  s->sc.edge_emu_buffer = NULL;
856  s->me.scratchpad = NULL;
857  s->me.temp =
858  s->sc.rd_scratchpad =
859  s->sc.b_scratchpad =
860  s->sc.obmc_scratchpad = NULL;
861 
862 
863  s->bitstream_buffer = NULL;
864  s->allocated_bitstream_buffer_size = 0;
865  s->picture = NULL;
866  s->mb_type = NULL;
867  s->p_mv_table_base = NULL;
868  s->b_forw_mv_table_base = NULL;
869  s->b_back_mv_table_base = NULL;
870  s->b_bidir_forw_mv_table_base = NULL;
871  s->b_bidir_back_mv_table_base = NULL;
872  s->b_direct_mv_table_base = NULL;
873  s->p_mv_table = NULL;
874  s->b_forw_mv_table = NULL;
875  s->b_back_mv_table = NULL;
876  s->b_bidir_forw_mv_table = NULL;
877  s->b_bidir_back_mv_table = NULL;
878  s->b_direct_mv_table = NULL;
879  for (i = 0; i < 2; i++) {
880  for (j = 0; j < 2; j++) {
881  for (k = 0; k < 2; k++) {
882  s->b_field_mv_table_base[i][j][k] = NULL;
883  s->b_field_mv_table[i][j][k] = NULL;
884  }
885  s->b_field_select_table[i][j] = NULL;
886  s->p_field_mv_table_base[i][j] = NULL;
887  s->p_field_mv_table[i][j] = NULL;
888  }
889  s->p_field_select_table[i] = NULL;
890  }
891 
892  s->dc_val_base = NULL;
893  s->coded_block_base = NULL;
894  s->mbintra_table = NULL;
895  s->cbp_table = NULL;
896  s->pred_dir_table = NULL;
897 
898  s->mbskip_table = NULL;
899 
900  s->er.error_status_table = NULL;
901  s->er.er_temp_buffer = NULL;
902  s->mb_index2xy = NULL;
903  s->lambda_table = NULL;
904 
905  s->cplx_tab = NULL;
906  s->bits_tab = NULL;
907 }
908 
909 /**
910  * init common structure for both encoder and decoder.
911  * this assumes that some variables like width/height are already set
912  */
914 {
915  int i, ret;
916  int nb_slices = (HAVE_THREADS &&
917  s->avctx->active_thread_type & FF_THREAD_SLICE) ?
918  s->avctx->thread_count : 1;
919 
920  clear_context(s);
921 
922  if (s->encoding && s->avctx->slices)
923  nb_slices = s->avctx->slices;
924 
925  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
926  s->mb_height = (s->height + 31) / 32 * 2;
927  else
928  s->mb_height = (s->height + 15) / 16;
929 
930  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
931  av_log(s->avctx, AV_LOG_ERROR,
932  "decoding to AV_PIX_FMT_NONE is not supported.\n");
933  return AVERROR(EINVAL);
934  }
935 
936  if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
937  int max_slices;
938  if (s->mb_height)
939  max_slices = FFMIN(MAX_THREADS, s->mb_height);
940  else
941  max_slices = MAX_THREADS;
942  av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
943  " reducing to %d\n", nb_slices, max_slices);
944  nb_slices = max_slices;
945  }
946 
947  if ((s->width || s->height) &&
948  av_image_check_size(s->width, s->height, 0, s->avctx))
949  return AVERROR(EINVAL);
950 
951  dct_init(s);
952 
953  /* set chroma shifts */
954  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
955  &s->chroma_x_shift,
956  &s->chroma_y_shift);
957  if (ret)
958  return ret;
959 
960  if (!FF_ALLOCZ_TYPED_ARRAY(s->picture, MAX_PICTURE_COUNT))
961  return AVERROR(ENOMEM);
962  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
963  s->picture[i].f = av_frame_alloc();
964  if (!s->picture[i].f)
965  goto fail_nomem;
966  }
967 
968  if (!(s->next_picture.f = av_frame_alloc()) ||
969  !(s->last_picture.f = av_frame_alloc()) ||
970  !(s->current_picture.f = av_frame_alloc()) ||
971  !(s->new_picture.f = av_frame_alloc()))
972  goto fail_nomem;
973 
974  if ((ret = init_context_frame(s)))
975  goto fail;
976 
977 #if FF_API_FLAG_TRUNCATED
978  s->parse_context.state = -1;
979 #endif
980 
981  s->context_initialized = 1;
982  memset(s->thread_context, 0, sizeof(s->thread_context));
983  s->thread_context[0] = s;
984  s->slice_context_count = nb_slices;
985 
986 // if (s->width && s->height) {
988  if (ret < 0)
989  goto fail;
990 // }
991 
992  return 0;
993  fail_nomem:
994  ret = AVERROR(ENOMEM);
995  fail:
997  return ret;
998 }
999 
1000 /**
1001  * Frees and resets MpegEncContext fields depending on the resolution
1002  * as well as the slice thread contexts.
1003  * Is used during resolution changes to avoid a full reinitialization of the
1004  * codec.
1005  */
1007 {
1008  int i, j, k;
1009 
1011 
1012  av_freep(&s->mb_type);
1013  av_freep(&s->p_mv_table_base);
1014  av_freep(&s->b_forw_mv_table_base);
1015  av_freep(&s->b_back_mv_table_base);
1016  av_freep(&s->b_bidir_forw_mv_table_base);
1017  av_freep(&s->b_bidir_back_mv_table_base);
1018  av_freep(&s->b_direct_mv_table_base);
1019  s->p_mv_table = NULL;
1020  s->b_forw_mv_table = NULL;
1021  s->b_back_mv_table = NULL;
1022  s->b_bidir_forw_mv_table = NULL;
1023  s->b_bidir_back_mv_table = NULL;
1024  s->b_direct_mv_table = NULL;
1025  for (i = 0; i < 2; i++) {
1026  for (j = 0; j < 2; j++) {
1027  for (k = 0; k < 2; k++) {
1028  av_freep(&s->b_field_mv_table_base[i][j][k]);
1029  s->b_field_mv_table[i][j][k] = NULL;
1030  }
1031  av_freep(&s->b_field_select_table[i][j]);
1032  av_freep(&s->p_field_mv_table_base[i][j]);
1033  s->p_field_mv_table[i][j] = NULL;
1034  }
1035  av_freep(&s->p_field_select_table[i]);
1036  }
1037 
1038  av_freep(&s->dc_val_base);
1039  av_freep(&s->coded_block_base);
1040  av_freep(&s->mbintra_table);
1041  av_freep(&s->cbp_table);
1042  av_freep(&s->pred_dir_table);
1043 
1044  av_freep(&s->mbskip_table);
1045 
1046  av_freep(&s->er.error_status_table);
1047  av_freep(&s->er.er_temp_buffer);
1048  av_freep(&s->mb_index2xy);
1049  av_freep(&s->lambda_table);
1050 
1051  av_freep(&s->cplx_tab);
1052  av_freep(&s->bits_tab);
1053 
1054  s->linesize = s->uvlinesize = 0;
1055 }
1056 
1058 {
1059  int i, err = 0;
1060 
1061  if (!s->context_initialized)
1062  return AVERROR(EINVAL);
1063 
1065 
1066  if (s->picture)
1067  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1068  s->picture[i].needs_realloc = 1;
1069  }
1070 
1071  s->last_picture_ptr =
1072  s->next_picture_ptr =
1073  s->current_picture_ptr = NULL;
1074 
1075  // init
1076  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1077  s->mb_height = (s->height + 31) / 32 * 2;
1078  else
1079  s->mb_height = (s->height + 15) / 16;
1080 
1081  if ((s->width || s->height) &&
1082  (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1083  goto fail;
1084 
1085  /* set chroma shifts */
1086  err = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1087  &s->chroma_x_shift,
1088  &s->chroma_y_shift);
1089  if (err < 0)
1090  goto fail;
1091 
1092  if ((err = init_context_frame(s)))
1093  goto fail;
1094 
1095  memset(s->thread_context, 0, sizeof(s->thread_context));
1096  s->thread_context[0] = s;
1097 
1098  if (s->width && s->height) {
1099  err = init_duplicate_contexts(s);
1100  if (err < 0)
1101  goto fail;
1102  }
1103  s->context_reinit = 0;
1104 
1105  return 0;
1106  fail:
1108  s->context_reinit = 1;
1109  return err;
1110 }
1111 
1112 /* init common structure for both encoder and decoder */
1114 {
1115  int i;
1116 
1117  if (!s)
1118  return;
1119 
1121  if (s->slice_context_count > 1)
1122  s->slice_context_count = 1;
1123 
1124 #if FF_API_FLAG_TRUNCATED
1125  av_freep(&s->parse_context.buffer);
1126  s->parse_context.buffer_size = 0;
1127 #endif
1128 
1129  av_freep(&s->bitstream_buffer);
1130  s->allocated_bitstream_buffer_size = 0;
1131 
1132  if (!s->avctx)
1133  return;
1134 
1135  if (s->picture) {
1136  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1137  ff_free_picture_tables(&s->picture[i]);
1138  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1139  av_frame_free(&s->picture[i].f);
1140  }
1141  }
1142  av_freep(&s->picture);
1143  ff_free_picture_tables(&s->last_picture);
1144  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1145  av_frame_free(&s->last_picture.f);
1146  ff_free_picture_tables(&s->current_picture);
1147  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1148  av_frame_free(&s->current_picture.f);
1149  ff_free_picture_tables(&s->next_picture);
1150  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1151  av_frame_free(&s->next_picture.f);
1152  ff_free_picture_tables(&s->new_picture);
1153  ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1154  av_frame_free(&s->new_picture.f);
1155 
1156  s->context_initialized = 0;
1157  s->context_reinit = 0;
1158  s->last_picture_ptr =
1159  s->next_picture_ptr =
1160  s->current_picture_ptr = NULL;
1161  s->linesize = s->uvlinesize = 0;
1162 }
1163 
1164 
1165 static void gray_frame(AVFrame *frame)
1166 {
1167  int i, h_chroma_shift, v_chroma_shift;
1168 
1169  av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1170 
1171  for(i=0; i<frame->height; i++)
1172  memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1173  for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1174  memset(frame->data[1] + frame->linesize[1]*i,
1175  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1176  memset(frame->data[2] + frame->linesize[2]*i,
1177  0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
1178  }
1179 }
1180 
1181 /**
1182  * generic function called after decoding
1183  * the header and before a frame is decoded.
1184  */
1186 {
1187  int i, ret;
1188  Picture *pic;
1189  s->mb_skipped = 0;
1190 
1191  if (!ff_thread_can_start_frame(avctx)) {
1192  av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1193  return -1;
1194  }
1195 
1196  /* mark & release old frames */
1197  if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1198  s->last_picture_ptr != s->next_picture_ptr &&
1199  s->last_picture_ptr->f->buf[0]) {
1200  ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1201  }
1202 
1203  /* release forgotten pictures */
1204  /* if (MPEG-124 / H.263) */
1205  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1206  if (&s->picture[i] != s->last_picture_ptr &&
1207  &s->picture[i] != s->next_picture_ptr &&
1208  s->picture[i].reference && !s->picture[i].needs_realloc) {
1209  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1210  }
1211  }
1212 
1213  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1214  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1215  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1216 
1217  /* release non reference frames */
1218  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1219  if (!s->picture[i].reference)
1220  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1221  }
1222 
1223  if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1224  // we already have an unused image
1225  // (maybe it was set before reading the header)
1226  pic = s->current_picture_ptr;
1227  } else {
1228  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1229  if (i < 0) {
1230  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1231  return i;
1232  }
1233  pic = &s->picture[i];
1234  }
1235 
1236  pic->reference = 0;
1237  if (!s->droppable) {
1238  if (s->pict_type != AV_PICTURE_TYPE_B)
1239  pic->reference = 3;
1240  }
1241 
1242  pic->f->coded_picture_number = s->coded_picture_number++;
1243 
1244  if (alloc_picture(s, pic) < 0)
1245  return -1;
1246 
1247  s->current_picture_ptr = pic;
1248  // FIXME use only the vars from current_pic
1249  s->current_picture_ptr->f->top_field_first = s->top_field_first;
1250  if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1251  s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1252  if (s->picture_structure != PICT_FRAME)
1253  s->current_picture_ptr->f->top_field_first =
1254  (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1255  }
1256  s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1257  !s->progressive_sequence;
1258  s->current_picture_ptr->field_picture = s->picture_structure != PICT_FRAME;
1259 
1260  s->current_picture_ptr->f->pict_type = s->pict_type;
1261  // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
1262  // s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1263  s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1264 
1265  if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1266  s->current_picture_ptr)) < 0)
1267  return ret;
1268 
1269  if (s->pict_type != AV_PICTURE_TYPE_B) {
1270  s->last_picture_ptr = s->next_picture_ptr;
1271  if (!s->droppable)
1272  s->next_picture_ptr = s->current_picture_ptr;
1273  }
1274  ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1275  s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1276  s->last_picture_ptr ? s->last_picture_ptr->f->data[0] : NULL,
1277  s->next_picture_ptr ? s->next_picture_ptr->f->data[0] : NULL,
1278  s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1279  s->pict_type, s->droppable);
1280 
1281  if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1282  (s->pict_type != AV_PICTURE_TYPE_I)) {
1283  int h_chroma_shift, v_chroma_shift;
1284  av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1285  &h_chroma_shift, &v_chroma_shift);
1286  if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1287  av_log(avctx, AV_LOG_DEBUG,
1288  "allocating dummy last picture for B frame\n");
1289  else if (s->pict_type != AV_PICTURE_TYPE_I)
1290  av_log(avctx, AV_LOG_ERROR,
1291  "warning: first frame is no keyframe\n");
1292 
1293  /* Allocate a dummy frame */
1294  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1295  if (i < 0) {
1296  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1297  return i;
1298  }
1299  s->last_picture_ptr = &s->picture[i];
1300 
1301  s->last_picture_ptr->reference = 3;
1302  s->last_picture_ptr->f->key_frame = 0;
1303  s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1304 
1305  if (alloc_picture(s, s->last_picture_ptr) < 0) {
1306  s->last_picture_ptr = NULL;
1307  return -1;
1308  }
1309 
1310  if (!avctx->hwaccel) {
1311  for(i=0; i<avctx->height; i++)
1312  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1313  0x80, avctx->width);
1314  if (s->last_picture_ptr->f->data[2]) {
1315  for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1316  memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1317  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1318  memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1319  0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1320  }
1321  }
1322 
1323  if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1324  for(i=0; i<avctx->height; i++)
1325  memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1326  }
1327  }
1328 
1329  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1330  ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1331  }
1332  if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1333  s->pict_type == AV_PICTURE_TYPE_B) {
1334  /* Allocate a dummy frame */
1335  i = ff_find_unused_picture(s->avctx, s->picture, 0);
1336  if (i < 0) {
1337  av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1338  return i;
1339  }
1340  s->next_picture_ptr = &s->picture[i];
1341 
1342  s->next_picture_ptr->reference = 3;
1343  s->next_picture_ptr->f->key_frame = 0;
1344  s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1345 
1346  if (alloc_picture(s, s->next_picture_ptr) < 0) {
1347  s->next_picture_ptr = NULL;
1348  return -1;
1349  }
1350  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1351  ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1352  }
1353 
1354 #if 0 // BUFREF-FIXME
1355  memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1356  memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1357 #endif
1358  if (s->last_picture_ptr) {
1359  if (s->last_picture_ptr->f->buf[0] &&
1360  (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1361  s->last_picture_ptr)) < 0)
1362  return ret;
1363  }
1364  if (s->next_picture_ptr) {
1365  if (s->next_picture_ptr->f->buf[0] &&
1366  (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1367  s->next_picture_ptr)) < 0)
1368  return ret;
1369  }
1370 
1371  av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1372  s->last_picture_ptr->f->buf[0]));
1373 
1374  if (s->picture_structure!= PICT_FRAME) {
1375  int i;
1376  for (i = 0; i < 4; i++) {
1377  if (s->picture_structure == PICT_BOTTOM_FIELD) {
1378  s->current_picture.f->data[i] +=
1379  s->current_picture.f->linesize[i];
1380  }
1381  s->current_picture.f->linesize[i] *= 2;
1382  s->last_picture.f->linesize[i] *= 2;
1383  s->next_picture.f->linesize[i] *= 2;
1384  }
1385  }
1386 
1387  /* set dequantizer, we can't do it during init as
1388  * it might change for MPEG-4 and we can't do it in the header
1389  * decode as init is not called for MPEG-4 there yet */
1390  if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1391  s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1392  s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1393  } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1394  s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1395  s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1396  } else {
1397  s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1398  s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1399  }
1400 
1401  if (s->avctx->debug & FF_DEBUG_NOMC) {
1402  gray_frame(s->current_picture_ptr->f);
1403  }
1404 
1405  return 0;
1406 }
1407 
1408 /* called after a frame has been decoded. */
1410 {
1411  emms_c();
1412 
1413  if (s->current_picture.reference)
1414  ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1415 }
1416 
1418 {
1419  ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
1420  p->qscale_table, p->motion_val,
1421  s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
1422 }
1423 
1425 {
1426  AVVideoEncParams *par;
1427  int mult = (qp_type == FF_QSCALE_TYPE_MPEG1) ? 2 : 1;
1428  unsigned int nb_mb = p->alloc_mb_height * p->alloc_mb_width;
1429  unsigned int x, y;
1430 
1431  if (!(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS))
1432  return 0;
1433 
1435  if (!par)
1436  return AVERROR(ENOMEM);
1437 
1438  for (y = 0; y < p->alloc_mb_height; y++)
1439  for (x = 0; x < p->alloc_mb_width; x++) {
1440  const unsigned int block_idx = y * p->alloc_mb_width + x;
1441  const unsigned int mb_xy = y * p->alloc_mb_stride + x;
1442  AVVideoBlockParams *b = av_video_enc_params_block(par, block_idx);
1443 
1444  b->src_x = x * 16;
1445  b->src_y = y * 16;
1446  b->w = 16;
1447  b->h = 16;
1448 
1449  b->delta_qp = p->qscale_table[mb_xy] * mult;
1450  }
1451 
1452  return 0;
1453 }
1454 
1456  uint8_t *dest, uint8_t *src,
1457  int field_based, int field_select,
1458  int src_x, int src_y,
1459  int width, int height, ptrdiff_t stride,
1460  int h_edge_pos, int v_edge_pos,
1461  int w, int h, h264_chroma_mc_func *pix_op,
1462  int motion_x, int motion_y)
1463 {
1464  const int lowres = s->avctx->lowres;
1465  const int op_index = FFMIN(lowres, 3);
1466  const int s_mask = (2 << lowres) - 1;
1467  int emu = 0;
1468  int sx, sy;
1469 
1470  if (s->quarter_sample) {
1471  motion_x /= 2;
1472  motion_y /= 2;
1473  }
1474 
1475  sx = motion_x & s_mask;
1476  sy = motion_y & s_mask;
1477  src_x += motion_x >> lowres + 1;
1478  src_y += motion_y >> lowres + 1;
1479 
1480  src += src_y * stride + src_x;
1481 
1482  if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
1483  (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1484  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src,
1485  s->linesize, s->linesize,
1486  w + 1, (h + 1) << field_based,
1487  src_x, src_y << field_based,
1488  h_edge_pos, v_edge_pos);
1489  src = s->sc.edge_emu_buffer;
1490  emu = 1;
1491  }
1492 
1493  sx = (sx << 2) >> lowres;
1494  sy = (sy << 2) >> lowres;
1495  if (field_select)
1496  src += s->linesize;
1497  pix_op[op_index](dest, src, stride, h, sx, sy);
1498  return emu;
1499 }
1500 
1501 /* apply one mpeg motion vector to the three components */
1503  uint8_t *dest_y,
1504  uint8_t *dest_cb,
1505  uint8_t *dest_cr,
1506  int field_based,
1507  int bottom_field,
1508  int field_select,
1509  uint8_t **ref_picture,
1510  h264_chroma_mc_func *pix_op,
1511  int motion_x, int motion_y,
1512  int h, int mb_y)
1513 {
1514  uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1515  int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
1516  ptrdiff_t uvlinesize, linesize;
1517  const int lowres = s->avctx->lowres;
1518  const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3);
1519  const int block_s = 8>>lowres;
1520  const int s_mask = (2 << lowres) - 1;
1521  const int h_edge_pos = s->h_edge_pos >> lowres;
1522  const int v_edge_pos = s->v_edge_pos >> lowres;
1523  linesize = s->current_picture.f->linesize[0] << field_based;
1524  uvlinesize = s->current_picture.f->linesize[1] << field_based;
1525 
1526  // FIXME obviously not perfect but qpel will not work in lowres anyway
1527  if (s->quarter_sample) {
1528  motion_x /= 2;
1529  motion_y /= 2;
1530  }
1531 
1532  if(field_based){
1533  motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1534  }
1535 
1536  sx = motion_x & s_mask;
1537  sy = motion_y & s_mask;
1538  src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1539  src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1540 
1541  if (s->out_format == FMT_H263) {
1542  uvsx = ((motion_x >> 1) & s_mask) | (sx & 1);
1543  uvsy = ((motion_y >> 1) & s_mask) | (sy & 1);
1544  uvsrc_x = src_x >> 1;
1545  uvsrc_y = src_y >> 1;
1546  } else if (s->out_format == FMT_H261) {
1547  // even chroma mv's are full pel in H261
1548  mx = motion_x / 4;
1549  my = motion_y / 4;
1550  uvsx = (2 * mx) & s_mask;
1551  uvsy = (2 * my) & s_mask;
1552  uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1553  uvsrc_y = mb_y * block_s + (my >> lowres);
1554  } else {
1555  if(s->chroma_y_shift){
1556  mx = motion_x / 2;
1557  my = motion_y / 2;
1558  uvsx = mx & s_mask;
1559  uvsy = my & s_mask;
1560  uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1);
1561  uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1);
1562  } else {
1563  if(s->chroma_x_shift){
1564  //Chroma422
1565  mx = motion_x / 2;
1566  uvsx = mx & s_mask;
1567  uvsy = motion_y & s_mask;
1568  uvsrc_y = src_y;
1569  uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1570  } else {
1571  //Chroma444
1572  uvsx = motion_x & s_mask;
1573  uvsy = motion_y & s_mask;
1574  uvsrc_x = src_x;
1575  uvsrc_y = src_y;
1576  }
1577  }
1578  }
1579 
1580  ptr_y = ref_picture[0] + src_y * linesize + src_x;
1581  ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1582  ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1583 
1584  if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 ||
1585  (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1586  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
1587  linesize >> field_based, linesize >> field_based,
1588  17, 17 + field_based,
1589  src_x, src_y << field_based, h_edge_pos,
1590  v_edge_pos);
1591  ptr_y = s->sc.edge_emu_buffer;
1592  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1593  uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
1594  uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
1595  if (s->workaround_bugs & FF_BUG_IEDGE)
1596  vbuf -= s->uvlinesize;
1597  s->vdsp.emulated_edge_mc(ubuf, ptr_cb,
1598  uvlinesize >> field_based, uvlinesize >> field_based,
1599  9, 9 + field_based,
1600  uvsrc_x, uvsrc_y << field_based,
1601  h_edge_pos >> 1, v_edge_pos >> 1);
1602  s->vdsp.emulated_edge_mc(vbuf, ptr_cr,
1603  uvlinesize >> field_based,uvlinesize >> field_based,
1604  9, 9 + field_based,
1605  uvsrc_x, uvsrc_y << field_based,
1606  h_edge_pos >> 1, v_edge_pos >> 1);
1607  ptr_cb = ubuf;
1608  ptr_cr = vbuf;
1609  }
1610  }
1611 
1612  // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
1613  if (bottom_field) {
1614  dest_y += s->linesize;
1615  dest_cb += s->uvlinesize;
1616  dest_cr += s->uvlinesize;
1617  }
1618 
1619  if (field_select) {
1620  ptr_y += s->linesize;
1621  ptr_cb += s->uvlinesize;
1622  ptr_cr += s->uvlinesize;
1623  }
1624 
1625  sx = (sx << 2) >> lowres;
1626  sy = (sy << 2) >> lowres;
1627  pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1628 
1629  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1630  int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
1631  uvsx = (uvsx << 2) >> lowres;
1632  uvsy = (uvsy << 2) >> lowres;
1633  if (hc) {
1634  pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
1635  pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
1636  }
1637  }
1638  // FIXME h261 lowres loop filter
1639 }
1640 
1642  uint8_t *dest_cb, uint8_t *dest_cr,
1643  uint8_t **ref_picture,
1644  h264_chroma_mc_func * pix_op,
1645  int mx, int my)
1646 {
1647  const int lowres = s->avctx->lowres;
1648  const int op_index = FFMIN(lowres, 3);
1649  const int block_s = 8 >> lowres;
1650  const int s_mask = (2 << lowres) - 1;
1651  const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1652  const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1653  int emu = 0, src_x, src_y, sx, sy;
1654  ptrdiff_t offset;
1655  uint8_t *ptr;
1656 
1657  if (s->quarter_sample) {
1658  mx /= 2;
1659  my /= 2;
1660  }
1661 
1662  /* In case of 8X8, we construct a single chroma motion vector
1663  with a special rounding */
1664  mx = ff_h263_round_chroma(mx);
1665  my = ff_h263_round_chroma(my);
1666 
1667  sx = mx & s_mask;
1668  sy = my & s_mask;
1669  src_x = s->mb_x * block_s + (mx >> lowres + 1);
1670  src_y = s->mb_y * block_s + (my >> lowres + 1);
1671 
1672  offset = src_y * s->uvlinesize + src_x;
1673  ptr = ref_picture[1] + offset;
1674  if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
1675  (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
1676  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1677  s->uvlinesize, s->uvlinesize,
1678  9, 9,
1679  src_x, src_y, h_edge_pos, v_edge_pos);
1680  ptr = s->sc.edge_emu_buffer;
1681  emu = 1;
1682  }
1683  sx = (sx << 2) >> lowres;
1684  sy = (sy << 2) >> lowres;
1685  pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1686 
1687  ptr = ref_picture[2] + offset;
1688  if (emu) {
1689  s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
1690  s->uvlinesize, s->uvlinesize,
1691  9, 9,
1692  src_x, src_y, h_edge_pos, v_edge_pos);
1693  ptr = s->sc.edge_emu_buffer;
1694  }
1695  pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1696 }
1697 
1698 /**
1699  * motion compensation of a single macroblock
1700  * @param s context
1701  * @param dest_y luma destination pointer
1702  * @param dest_cb chroma cb/u destination pointer
1703  * @param dest_cr chroma cr/v destination pointer
1704  * @param dir direction (0->forward, 1->backward)
1705  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1706  * @param pix_op halfpel motion compensation function (average or put normally)
1707  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1708  */
1709 static inline void MPV_motion_lowres(MpegEncContext *s,
1710  uint8_t *dest_y, uint8_t *dest_cb,
1711  uint8_t *dest_cr,
1712  int dir, uint8_t **ref_picture,
1713  h264_chroma_mc_func *pix_op)
1714 {
1715  int mx, my;
1716  int mb_x, mb_y, i;
1717  const int lowres = s->avctx->lowres;
1718  const int block_s = 8 >>lowres;
1719 
1720  mb_x = s->mb_x;
1721  mb_y = s->mb_y;
1722 
1723  switch (s->mv_type) {
1724  case MV_TYPE_16X16:
1725  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1726  0, 0, 0,
1727  ref_picture, pix_op,
1728  s->mv[dir][0][0], s->mv[dir][0][1],
1729  2 * block_s, mb_y);
1730  break;
1731  case MV_TYPE_8X8:
1732  mx = 0;
1733  my = 0;
1734  for (i = 0; i < 4; i++) {
1735  hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
1736  s->linesize) * block_s,
1737  ref_picture[0], 0, 0,
1738  (2 * mb_x + (i & 1)) * block_s,
1739  (2 * mb_y + (i >> 1)) * block_s,
1740  s->width, s->height, s->linesize,
1741  s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1742  block_s, block_s, pix_op,
1743  s->mv[dir][i][0], s->mv[dir][i][1]);
1744 
1745  mx += s->mv[dir][i][0];
1746  my += s->mv[dir][i][1];
1747  }
1748 
1749  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
1750  chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
1751  pix_op, mx, my);
1752  break;
1753  case MV_TYPE_FIELD:
1754  if (s->picture_structure == PICT_FRAME) {
1755  /* top field */
1756  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1757  1, 0, s->field_select[dir][0],
1758  ref_picture, pix_op,
1759  s->mv[dir][0][0], s->mv[dir][0][1],
1760  block_s, mb_y);
1761  /* bottom field */
1762  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1763  1, 1, s->field_select[dir][1],
1764  ref_picture, pix_op,
1765  s->mv[dir][1][0], s->mv[dir][1][1],
1766  block_s, mb_y);
1767  } else {
1768  if (s->picture_structure != s->field_select[dir][0] + 1 &&
1769  s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
1770  ref_picture = s->current_picture_ptr->f->data;
1771 
1772  }
1773  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1774  0, 0, s->field_select[dir][0],
1775  ref_picture, pix_op,
1776  s->mv[dir][0][0],
1777  s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
1778  }
1779  break;
1780  case MV_TYPE_16X8:
1781  for (i = 0; i < 2; i++) {
1782  uint8_t **ref2picture;
1783 
1784  if (s->picture_structure == s->field_select[dir][i] + 1 ||
1785  s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
1786  ref2picture = ref_picture;
1787  } else {
1788  ref2picture = s->current_picture_ptr->f->data;
1789  }
1790 
1791  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1792  0, 0, s->field_select[dir][i],
1793  ref2picture, pix_op,
1794  s->mv[dir][i][0], s->mv[dir][i][1] +
1795  2 * block_s * i, block_s, mb_y >> 1);
1796 
1797  dest_y += 2 * block_s * s->linesize;
1798  dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1799  dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
1800  }
1801  break;
1802  case MV_TYPE_DMV:
1803  if (s->picture_structure == PICT_FRAME) {
1804  for (i = 0; i < 2; i++) {
1805  int j;
1806  for (j = 0; j < 2; j++) {
1807  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1808  1, j, j ^ i,
1809  ref_picture, pix_op,
1810  s->mv[dir][2 * i + j][0],
1811  s->mv[dir][2 * i + j][1],
1812  block_s, mb_y);
1813  }
1814  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1815  }
1816  } else {
1817  for (i = 0; i < 2; i++) {
1818  mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1819  0, 0, s->picture_structure != i + 1,
1820  ref_picture, pix_op,
1821  s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
1822  2 * block_s, mb_y >> 1);
1823 
1824  // after put we make avg of the same block
1825  pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
1826 
1827  // opposite parity is always in the same
1828  // frame if this is second field
1829  if (!s->first_field) {
1830  ref_picture = s->current_picture_ptr->f->data;
1831  }
1832  }
1833  }
1834  break;
1835  default:
1836  av_assert2(0);
1837  }
1838 }
1839 
1840 /**
1841  * find the lowest MB row referenced in the MVs
1842  */
1844 {
1845  int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1846  int my, off, i, mvs;
1847 
1848  if (s->picture_structure != PICT_FRAME || s->mcsel)
1849  goto unhandled;
1850 
1851  switch (s->mv_type) {
1852  case MV_TYPE_16X16:
1853  mvs = 1;
1854  break;
1855  case MV_TYPE_16X8:
1856  mvs = 2;
1857  break;
1858  case MV_TYPE_8X8:
1859  mvs = 4;
1860  break;
1861  default:
1862  goto unhandled;
1863  }
1864 
1865  for (i = 0; i < mvs; i++) {
1866  my = s->mv[dir][i][1];
1867  my_max = FFMAX(my_max, my);
1868  my_min = FFMIN(my_min, my);
1869  }
1870 
1871  off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
1872 
1873  return av_clip(s->mb_y + off, 0, s->mb_height - 1);
1874 unhandled:
1875  return s->mb_height-1;
1876 }
1877 
1878 /* put block[] to dest[] */
1879 static inline void put_dct(MpegEncContext *s,
1880  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1881 {
1882  s->dct_unquantize_intra(s, block, i, qscale);
1883  s->idsp.idct_put(dest, line_size, block);
1884 }
1885 
1886 /* add block[] to dest[] */
1887 static inline void add_dct(MpegEncContext *s,
1888  int16_t *block, int i, uint8_t *dest, int line_size)
1889 {
1890  if (s->block_last_index[i] >= 0) {
1891  s->idsp.idct_add(dest, line_size, block);
1892  }
1893 }
1894 
1895 static inline void add_dequant_dct(MpegEncContext *s,
1896  int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
1897 {
1898  if (s->block_last_index[i] >= 0) {
1899  s->dct_unquantize_inter(s, block, i, qscale);
1900 
1901  s->idsp.idct_add(dest, line_size, block);
1902  }
1903 }
1904 
1905 /**
1906  * Clean dc, ac, coded_block for the current non-intra MB.
1907  */
1909 {
1910  int wrap = s->b8_stride;
1911  int xy = s->block_index[0];
1912 
1913  s->dc_val[0][xy ] =
1914  s->dc_val[0][xy + 1 ] =
1915  s->dc_val[0][xy + wrap] =
1916  s->dc_val[0][xy + 1 + wrap] = 1024;
1917  /* ac pred */
1918  memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1919  memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1920  if (s->msmpeg4_version>=3) {
1921  s->coded_block[xy ] =
1922  s->coded_block[xy + 1 ] =
1923  s->coded_block[xy + wrap] =
1924  s->coded_block[xy + 1 + wrap] = 0;
1925  }
1926  /* chroma */
1927  wrap = s->mb_stride;
1928  xy = s->mb_x + s->mb_y * wrap;
1929  s->dc_val[1][xy] =
1930  s->dc_val[2][xy] = 1024;
1931  /* ac pred */
1932  memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1933  memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1934 
1935  s->mbintra_table[xy]= 0;
1936 }
1937 
1938 /* generic function called after a macroblock has been parsed by the
1939  decoder or after it has been encoded by the encoder.
1940 
1941  Important variables used:
1942  s->mb_intra : true if intra macroblock
1943  s->mv_dir : motion vector direction
1944  s->mv_type : motion vector type
1945  s->mv : motion vector
1946  s->interlaced_dct : true if interlaced dct used (mpeg2)
1947  */
1948 static av_always_inline
1950  int lowres_flag, int is_mpeg12)
1951 {
1952  const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1953 
1954  if (CONFIG_XVMC &&
1955  s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
1956  s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
1957  return;
1958  }
1959 
1960  if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1961  /* print DCT coefficients */
1962  int i,j;
1963  av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
1964  for(i=0; i<6; i++){
1965  for(j=0; j<64; j++){
1966  av_log(s->avctx, AV_LOG_DEBUG, "%5d",
1967  block[i][s->idsp.idct_permutation[j]]);
1968  }
1969  av_log(s->avctx, AV_LOG_DEBUG, "\n");
1970  }
1971  }
1972 
1973  s->current_picture.qscale_table[mb_xy] = s->qscale;
1974 
1975  /* update DC predictors for P macroblocks */
1976  if (!s->mb_intra) {
1977  if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1978  if(s->mbintra_table[mb_xy])
1980  } else {
1981  s->last_dc[0] =
1982  s->last_dc[1] =
1983  s->last_dc[2] = 128 << s->intra_dc_precision;
1984  }
1985  }
1986  else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1987  s->mbintra_table[mb_xy]=1;
1988 
1989  if ((s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor ||
1990  !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
1991  s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
1992  uint8_t *dest_y, *dest_cb, *dest_cr;
1993  int dct_linesize, dct_offset;
1994  op_pixels_func (*op_pix)[4];
1995  qpel_mc_func (*op_qpix)[16];
1996  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
1997  const int uvlinesize = s->current_picture.f->linesize[1];
1998  const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1999  const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2000 
2001  /* avoid copy if macroblock skipped in last frame too */
2002  /* skip only during decoding as we might trash the buffers during encoding a bit */
2003  if(!s->encoding){
2004  uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2005 
2006  if (s->mb_skipped) {
2007  s->mb_skipped= 0;
2008  av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2009  *mbskip_ptr = 1;
2010  } else if(!s->current_picture.reference) {
2011  *mbskip_ptr = 1;
2012  } else{
2013  *mbskip_ptr = 0; /* not skipped */
2014  }
2015  }
2016 
2017  dct_linesize = linesize << s->interlaced_dct;
2018  dct_offset = s->interlaced_dct ? linesize : linesize * block_size;
2019 
2020  if(readable){
2021  dest_y= s->dest[0];
2022  dest_cb= s->dest[1];
2023  dest_cr= s->dest[2];
2024  }else{
2025  dest_y = s->sc.b_scratchpad;
2026  dest_cb= s->sc.b_scratchpad+16*linesize;
2027  dest_cr= s->sc.b_scratchpad+32*linesize;
2028  }
2029 
2030  if (!s->mb_intra) {
2031  /* motion handling */
2032  /* decoding or more than one mb_type (MC was already done otherwise) */
2033  if(!s->encoding){
2034 
2035  if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2036  if (s->mv_dir & MV_DIR_FORWARD) {
2037  ff_thread_await_progress(&s->last_picture_ptr->tf,
2039  0);
2040  }
2041  if (s->mv_dir & MV_DIR_BACKWARD) {
2042  ff_thread_await_progress(&s->next_picture_ptr->tf,
2044  0);
2045  }
2046  }
2047 
2048  if(lowres_flag){
2049  h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2050 
2051  if (s->mv_dir & MV_DIR_FORWARD) {
2052  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
2053  op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2054  }
2055  if (s->mv_dir & MV_DIR_BACKWARD) {
2056  MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
2057  }
2058  }else{
2059  op_qpix = s->me.qpel_put;
2060  if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2061  op_pix = s->hdsp.put_pixels_tab;
2062  }else{
2063  op_pix = s->hdsp.put_no_rnd_pixels_tab;
2064  }
2065  if (s->mv_dir & MV_DIR_FORWARD) {
2066  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2067  op_pix = s->hdsp.avg_pixels_tab;
2068  op_qpix= s->me.qpel_avg;
2069  }
2070  if (s->mv_dir & MV_DIR_BACKWARD) {
2071  ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2072  }
2073  }
2074  }
2075 
2076  /* skip dequant / idct if we are really late ;) */
2077  if(s->avctx->skip_idct){
2078  if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2079  ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2080  || s->avctx->skip_idct >= AVDISCARD_ALL)
2081  goto skip_idct;
2082  }
2083 
2084  /* add dct residue */
2085  if(s->encoding || !( s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2086  || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2087  add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2088  add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2089  add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2090  add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2091 
2092  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2093  if (s->chroma_y_shift){
2094  add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2095  add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2096  }else{
2097  dct_linesize >>= 1;
2098  dct_offset >>=1;
2099  add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2100  add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2101  add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2102  add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2103  }
2104  }
2105  } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2106  add_dct(s, block[0], 0, dest_y , dct_linesize);
2107  add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
2108  add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
2109  add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2110 
2111  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2112  if(s->chroma_y_shift){//Chroma420
2113  add_dct(s, block[4], 4, dest_cb, uvlinesize);
2114  add_dct(s, block[5], 5, dest_cr, uvlinesize);
2115  }else{
2116  //chroma422
2117  dct_linesize = uvlinesize << s->interlaced_dct;
2118  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2119 
2120  add_dct(s, block[4], 4, dest_cb, dct_linesize);
2121  add_dct(s, block[5], 5, dest_cr, dct_linesize);
2122  add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2123  add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2124  if(!s->chroma_x_shift){//Chroma444
2125  add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2126  add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2127  add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2128  add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2129  }
2130  }
2131  }//fi gray
2132  }
2133  else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2134  ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2135  }
2136  } else {
2137  /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode.
2138  TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */
2139  if (s->avctx->bits_per_raw_sample > 8){
2140  const int act_block_size = block_size * 2;
2141 
2142  if(s->dpcm_direction == 0) {
2143  s->idsp.idct_put(dest_y, dct_linesize, (int16_t*)(*s->block32)[0]);
2144  s->idsp.idct_put(dest_y + act_block_size, dct_linesize, (int16_t*)(*s->block32)[1]);
2145  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, (int16_t*)(*s->block32)[2]);
2146  s->idsp.idct_put(dest_y + dct_offset + act_block_size, dct_linesize, (int16_t*)(*s->block32)[3]);
2147 
2148  dct_linesize = uvlinesize << s->interlaced_dct;
2149  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2150 
2151  s->idsp.idct_put(dest_cb, dct_linesize, (int16_t*)(*s->block32)[4]);
2152  s->idsp.idct_put(dest_cr, dct_linesize, (int16_t*)(*s->block32)[5]);
2153  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, (int16_t*)(*s->block32)[6]);
2154  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, (int16_t*)(*s->block32)[7]);
2155  if(!s->chroma_x_shift){//Chroma444
2156  s->idsp.idct_put(dest_cb + act_block_size, dct_linesize, (int16_t*)(*s->block32)[8]);
2157  s->idsp.idct_put(dest_cr + act_block_size, dct_linesize, (int16_t*)(*s->block32)[9]);
2158  s->idsp.idct_put(dest_cb + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[10]);
2159  s->idsp.idct_put(dest_cr + act_block_size + dct_offset, dct_linesize, (int16_t*)(*s->block32)[11]);
2160  }
2161  } else if(s->dpcm_direction == 1) {
2162  int i, w, h;
2163  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2164  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2165  for(i = 0; i < 3; i++) {
2166  int idx = 0;
2167  int vsub = i ? s->chroma_y_shift : 0;
2168  int hsub = i ? s->chroma_x_shift : 0;
2169  for(h = 0; h < (16 >> vsub); h++){
2170  for(w = 0; w < (16 >> hsub); w++)
2171  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2172  dest_pcm[i] += linesize[i] / 2;
2173  }
2174  }
2175  } else if(s->dpcm_direction == -1) {
2176  int i, w, h;
2177  uint16_t *dest_pcm[3] = {(uint16_t*)dest_y, (uint16_t*)dest_cb, (uint16_t*)dest_cr};
2178  int linesize[3] = {dct_linesize, uvlinesize, uvlinesize};
2179  for(i = 0; i < 3; i++) {
2180  int idx = 0;
2181  int vsub = i ? s->chroma_y_shift : 0;
2182  int hsub = i ? s->chroma_x_shift : 0;
2183  dest_pcm[i] += (linesize[i] / 2) * ((16 >> vsub) - 1);
2184  for(h = (16 >> vsub)-1; h >= 1; h--){
2185  for(w = (16 >> hsub)-1; w >= 1; w--)
2186  dest_pcm[i][w] = (*s->dpcm_macroblock)[i][idx++];
2187  dest_pcm[i] -= linesize[i] / 2;
2188  }
2189  }
2190  }
2191  }
2192  /* dct only in intra block */
2193  else if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2194  put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
2195  put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
2196  put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
2197  put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2198 
2199  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2200  if(s->chroma_y_shift){
2201  put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2202  put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2203  }else{
2204  dct_offset >>=1;
2205  dct_linesize >>=1;
2206  put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
2207  put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
2208  put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2209  put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2210  }
2211  }
2212  }else{
2213  s->idsp.idct_put(dest_y, dct_linesize, block[0]);
2214  s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
2215  s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]);
2216  s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2217 
2218  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2219  if(s->chroma_y_shift){
2220  s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2221  s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2222  }else{
2223 
2224  dct_linesize = uvlinesize << s->interlaced_dct;
2225  dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2226 
2227  s->idsp.idct_put(dest_cb, dct_linesize, block[4]);
2228  s->idsp.idct_put(dest_cr, dct_linesize, block[5]);
2229  s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2230  s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2231  if(!s->chroma_x_shift){//Chroma444
2232  s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]);
2233  s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]);
2234  s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2235  s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2236  }
2237  }
2238  }//gray
2239  }
2240  }
2241 skip_idct:
2242  if(!readable){
2243  s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2244  if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
2245  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2246  s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2247  }
2248  }
2249  }
2250 }
2251 
2253 {
2254 #if !CONFIG_SMALL
2255  if(s->out_format == FMT_MPEG1) {
2256  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
2257  else mpv_reconstruct_mb_internal(s, block, 0, 1);
2258  } else
2259 #endif
2260  if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
2261  else mpv_reconstruct_mb_internal(s, block, 0, 0);
2262 }
2263 
2265 {
2266  ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
2267  s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
2268  s->first_field, s->low_delay);
2269 }
2270 
2271 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2272  const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2273  const int uvlinesize = s->current_picture.f->linesize[1];
2274  const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
2275  const int height_of_mb = 4 - s->avctx->lowres;
2276 
2277  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2278  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2279  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2280  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2281  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2282  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;
2283  //block_index is not used by mpeg2, so it is not affected by chroma_format
2284 
2285  s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb);
2286  s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2287  s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
2288 
2289  if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2290  {
2291  if(s->picture_structure==PICT_FRAME){
2292  s->dest[0] += s->mb_y * linesize << height_of_mb;
2293  s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2294  s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
2295  }else{
2296  s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb;
2297  s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2298  s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
2299  av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2300  }
2301  }
2302 }
2303 
2305  int i;
2306  MpegEncContext *s = avctx->priv_data;
2307 
2308  if (!s || !s->picture)
2309  return;
2310 
2311  for (i = 0; i < MAX_PICTURE_COUNT; i++)
2312  ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
2313  s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2314 
2315  ff_mpeg_unref_picture(s->avctx, &s->current_picture);
2316  ff_mpeg_unref_picture(s->avctx, &s->last_picture);
2317  ff_mpeg_unref_picture(s->avctx, &s->next_picture);
2318 
2319  s->mb_x= s->mb_y= 0;
2320  s->closed_gop= 0;
2321 
2322 #if FF_API_FLAG_TRUNCATED
2323  s->parse_context.state= -1;
2324  s->parse_context.frame_start_found= 0;
2325  s->parse_context.overread= 0;
2326  s->parse_context.overread_index= 0;
2327  s->parse_context.index= 0;
2328  s->parse_context.last_index= 0;
2329 #endif
2330  s->bitstream_buffer_size=0;
2331  s->pp_time=0;
2332 }
2333 
2334 /**
2335  * set qscale and update qscale dependent variables.
2336  */
2337 void ff_set_qscale(MpegEncContext * s, int qscale)
2338 {
2339  if (qscale < 1)
2340  qscale = 1;
2341  else if (qscale > 31)
2342  qscale = 31;
2343 
2344  s->qscale = qscale;
2345  s->chroma_qscale= s->chroma_qscale_table[qscale];
2346 
2347  s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2348  s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2349 }
2350 
2352 {
2353  if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2354  ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2355 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:98
ff_h263_round_chroma
static int ff_h263_round_chroma(int x)
Definition: motion_est.h:101
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:913
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
stride
int stride
Definition: mace.c:144
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:256
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
free_duplicate_contexts
static void free_duplicate_contexts(MpegEncContext *s)
Definition: mpegvideo.c:460
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:96
ff_mpeg_framesize_alloc
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:58
blockdsp.h
FMT_MPEG1
@ FMT_MPEG1
Definition: mpegutils.h:123
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecContext::workaround_bugs
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
Definition: avcodec.h:1251
mpeg_motion_lowres
static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int field_based, int bottom_field, int field_select, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int motion_x, int motion_y, int h, int mb_y)
Definition: mpegvideo.c:1502
backup_duplicate_context
static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
Definition: mpegvideo.c:469
ff_mpv_common_defaults
void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
Definition: mpegvideo.c:676
hpel_motion_lowres
static int hpel_motion_lowres(MpegEncContext *s, uint8_t *dest, uint8_t *src, int field_based, int field_select, int src_x, int src_y, int width, int height, ptrdiff_t stride, int h_edge_pos, int v_edge_pos, int w, int h, h264_chroma_mc_func *pix_op, int motion_x, int motion_y)
Definition: mpegvideo.c:1455
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: pthread_frame.c:935
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:258
AVFrame::coded_picture_number
int coded_picture_number
picture number in bitstream order
Definition: frame.h:408
Picture::alloc_mb_width
int alloc_mb_width
mb_width used to allocate tables
Definition: mpegpicture.h:70
lowest_referenced_row
static int lowest_referenced_row(MpegEncContext *s, int dir)
find the lowest MB row referenced in the MVs
Definition: mpegvideo.c:1843
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:877
ff_mpv_common_frame_size_change
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1057
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
ff_free_picture_tables
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:454
last_picture
enum AVPictureType last_picture
Definition: movenc.c:69
b
#define b
Definition: input.c:40
ff_mpeg2_non_linear_qscale
const uint8_t ff_mpeg2_non_linear_qscale[32]
Definition: mpegvideodata.c:26
REBASE_PICTURE
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
ff_clean_intra_table_entries
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac, coded_block for the current non-intra MB.
Definition: mpegvideo.c:1908
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
init_duplicate_context
static int init_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:359
ff_mpv_common_init_arm
av_cold void ff_mpv_common_init_arm(MpegEncContext *s)
Definition: mpegvideo_arm.c:44
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2271
mpegvideo.h
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:88
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:247
Picture
Picture.
Definition: mpegpicture.h:45
AV_CODEC_FLAG_INTERLACED_ME
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:281
mpegutils.h
thread.h
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
free_duplicate_context
static void free_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:438
MV_DIR_BACKWARD
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:253
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:260
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:74
mpv_reconstruct_mb_internal
static av_always_inline void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], int lowres_flag, int is_mpeg12)
Definition: mpegvideo.c:1949
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:311
chroma_4mv_motion_lowres
static void chroma_4mv_motion_lowres(MpegEncContext *s, uint8_t *dest_cb, uint8_t *dest_cr, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int mx, int my)
Definition: mpegvideo.c:1641
AV_VIDEO_ENC_PARAMS_MPEG2
@ AV_VIDEO_ENC_PARAMS_MPEG2
Definition: video_enc_params.h:65
dct_unquantize_mpeg1_inter_c
static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:83
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
U
#define U(x)
Definition: vp56_arith.h:37
fail
#define fail()
Definition: checkasm.h:127
wrap
#define wrap(func)
Definition: neontest.h:65
h264_chroma_mc_func
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, ptrdiff_t srcStride, int h, int x, int y)
Definition: h264chroma.h:25
MpegEncContext::linesize
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:124
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2264
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:35
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2592
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:97
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:571
AVVideoEncParams
Video encoding parameters for a given frame.
Definition: video_enc_params.h:73
MAX_PICTURE_COUNT
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
dct_unquantize_mpeg1_intra_c
static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:54
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
mult
static int16_t mult(Float11 *f1, Float11 *f2)
Definition: g726.c:56
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1113
MpegEncContext::pblocks
int16_t(*[12] pblocks)[64]
Definition: mpegvideo.h:500
avassert.h
gray16
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:271
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:588
motion_vector.h
width
#define width
add_dct
static void add_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size)
Definition: mpegvideo.c:1887
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_mpeg_unref_picture
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:295
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
UPDATE_PICTURE
#define UPDATE_PICTURE(pic)
s1
#define s1
Definition: regdef.h:38
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:68
dct_unquantize_mpeg2_intra_bitexact
static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:142
FMT_H261
@ FMT_H261
Definition: mpegutils.h:124
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
limits.h
ff_mpegvideodsp_init
av_cold void ff_mpegvideodsp_init(MpegVideoDSPContext *c)
Definition: mpegvideodsp.c:110
f
#define f(width, name)
Definition: cbs_vp9.c:255
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
Picture::reference
int reference
Definition: mpegpicture.h:88
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
ff_find_unused_picture
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:440
ff_print_debug_info2
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t(*motion_val[2])[2], int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:103
NULL
#define NULL
Definition: coverity.c:32
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
me
#define me
Definition: vf_colormatrix.c:104
put_dct
static void put_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1879
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:255
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2337
mathops.h
FF_BUG_IEDGE
#define FF_BUG_IEDGE
Definition: avcodec.h:1266
lowres
static int lowres
Definition: ffplay.c:334
qpeldsp.h
ff_alternate_horizontal_scan
const uint8_t ff_alternate_horizontal_scan[64]
Definition: mpegvideodata.c:84
MpegEncContext::me
MotionEstContext me
Definition: mpegvideo.h:272
ff_alloc_picture
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int shared, int encoding, int chroma_x_shift, int chroma_y_shift, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride, ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
Allocate a Picture.
Definition: mpegpicture.c:232
ME_MAP_SIZE
#define ME_MAP_SIZE
Definition: motion_est.h:38
op_pixels_func
void(* op_pixels_func)(uint8_t *block, const uint8_t *pixels, ptrdiff_t line_size, int h)
Definition: hpeldsp.h:38
wmv2.h
qpel_mc_func
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
Definition: qpeldsp.h:65
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:51
dct_unquantize_mpeg2_intra_c
static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:112
MV_TYPE_8X8
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:257
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
av_video_enc_params_create_side_data
AVVideoEncParams * av_video_enc_params_create_side_data(AVFrame *frame, enum AVVideoEncParamsType type, unsigned int nb_blocks)
Allocates memory for AVEncodeInfoFrame plus an array of.
Definition: video_enc_params.c:60
FF_DEBUG_DCT_COEFF
#define FF_DEBUG_DCT_COEFF
Definition: avcodec.h:1308
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:53
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:243
ff_mpeg_ref_picture
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:355
FF_QSCALE_TYPE_MPEG1
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:96
ff_draw_horiz_band
void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:51
ff_mpeg_er_init
int ff_mpeg_er_init(MpegEncContext *s)
Definition: mpeg_er.c:100
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:54
ff_mpv_motion
void ff_mpv_motion(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, op_pixels_func(*pix_op)[4], qpel_mc_func(*qpix_op)[16])
Definition: mpegvideo_motion.c:974
alloc_picture
static int alloc_picture(MpegEncContext *s, Picture *pic)
Definition: mpegvideo.c:351
h264chroma.h
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1452
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2304
Picture::alloc_mb_height
int alloc_mb_height
mb_height used to allocate tables
Definition: mpegpicture.h:71
height
#define height
init_context_frame
static int init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
Definition: mpegvideo.c:716
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:524
mpegvideodata.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:259
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1424
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1417
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
dct_unquantize_mpeg2_inter_c
static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:176
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1451
clear_context
static void clear_context(MpegEncContext *s)
Definition: mpegvideo.c:831
AVCodec::id
enum AVCodecID id
Definition: codec.h:216
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
FMT_H263
@ FMT_H263
Definition: mpegutils.h:125
dct_unquantize_h263_inter_c
static void dct_unquantize_h263_inter_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:244
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:95
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
internal.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
ff_mpv_common_init_ppc
void ff_mpv_common_init_ppc(MpegEncContext *s)
Definition: mpegvideo_altivec.c:119
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
MpegEncContext::sc
ScratchpadContext sc
Definition: mpegvideo.h:192
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVVideoBlockParams
Data structure for storing block-level encoding information.
Definition: video_enc_params.h:120
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
ff_wmv2_add_mb
void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
Definition: wmv2.c:83
AVCodecContext::height
int height
Definition: avcodec.h:556
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1409
FF_DEBUG_NOMC
#define FF_DEBUG_NOMC
Definition: avcodec.h:1317
idctdsp.h
avcodec.h
msmpeg4.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
Picture::qscale_table
int8_t * qscale_table
Definition: mpegpicture.h:50
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1185
free_context_frame
static void free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution as well as the slice thread contex...
Definition: mpegvideo.c:1006
dct_init
static av_cold int dct_init(MpegEncContext *s)
Definition: mpegvideo.c:284
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
#define AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS
Decoding only.
Definition: avcodec.h:351
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
MpegEncContext::block
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:502
AVCodecContext
main external API structure.
Definition: avcodec.h:383
ScratchpadContext::edge_emu_buffer
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:499
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:46
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
dct_unquantize_h263_intra_c
static void dct_unquantize_h263_intra_c(MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.c:210
ff_mpv_common_init_x86
av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
Definition: mpegvideo.c:454
MPV_motion_lowres
static void MPV_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int dir, uint8_t **ref_picture, h264_chroma_mc_func *pix_op)
motion compensation of a single macroblock
Definition: mpegvideo.c:1709
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2252
ff_mpv_common_init_axp
av_cold void ff_mpv_common_init_axp(MpegEncContext *s)
Definition: mpegvideo_alpha.c:106
FF_MB_DECISION_RD
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:859
ff_mpv_common_init_mips
av_cold void ff_mpv_common_init_mips(MpegEncContext *s)
Definition: mpegvideo_init_mips.c:26
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:571
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
init_duplicate_contexts
static int init_duplicate_contexts(MpegEncContext *s)
Initialize an MpegEncContext's thread contexts.
Definition: mpegvideo.c:414
ff_default_chroma_qscale_table
const uint8_t ff_default_chroma_qscale_table[32]
Definition: mpegvideodata.c:21
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:272
COPY
#define COPY(a)
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:408
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:252
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:560
mpeg_er.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2351
add_dequant_dct
static void add_dequant_dct(MpegEncContext *s, int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
Definition: mpegvideo.c:1895
av_video_enc_params_block
static av_always_inline AVVideoBlockParams * av_video_enc_params_block(AVVideoEncParams *par, unsigned int idx)
Definition: video_enc_params.h:143
h
h
Definition: vp9dsp_template.c:2038
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:59
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:71
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo.c:699
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:50
int
int
Definition: ffmpeg_filter.c:156
mjpegenc.h
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
ff_mpv_common_init_neon
av_cold void ff_mpv_common_init_neon(MpegEncContext *s)
Definition: mpegvideo.c:127
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:71
gray8
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:277
gray_frame
static void gray_frame(AVFrame *frame)
Definition: mpegvideo.c:1165
Picture::alloc_mb_stride
int alloc_mb_stride
mb_stride used to allocate tables
Definition: mpegpicture.h:72
video_enc_params.h