?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of http://repo.or.cz/r/FFMpeg-mirror
[FFMpeg-mirror/DVCPRO-HD.git] / libavcodec / mpeg12.c
blobbb59f5455f63a12443767f8a719a926b0dae0bd5
1 /*
2 * MPEG1/2 decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * This file is part of FFmpeg.
7 *
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 /**
24 * @file mpeg12.c
25 * MPEG1/2 decoder
26 */
27
28 //#define DEBUG
29 #include "avcodec.h"
30 #include "dsputil.h"
31 #include "mpegvideo.h"
32
33 #include "mpeg12.h"
34 #include "mpeg12data.h"
35 #include "mpeg12decdata.h"
36 #include "bytestream.h"
37
38 //#undef NDEBUG
39 //#include <assert.h>
40
41
42 #define DC_VLC_BITS 9
43 #define MV_VLC_BITS 9
44 #define MBINCR_VLC_BITS 9
45 #define MB_PAT_VLC_BITS 9
46 #define MB_PTYPE_VLC_BITS 6
47 #define MB_BTYPE_VLC_BITS 6
48 #define TEX_VLC_BITS 9
49
50 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
51 DCTELEM *block,
52 int n);
53 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
54 DCTELEM *block,
55 int n);
56 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n);
57 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
58 DCTELEM *block,
59 int n);
60 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
61 DCTELEM *block,
62 int n);
63 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, DCTELEM *block, int n);
64 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s, DCTELEM *block, int n);
65 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred);
66 static void exchange_uv(MpegEncContext *s);
67
68 extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx);
69 extern int XVMC_field_end(MpegEncContext *s);
70 extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);
71 extern void XVMC_init_block(MpegEncContext *s);//set s->block
72
73 static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,PIX_FMT_NONE};
74 static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,PIX_FMT_NONE};
75 static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,PIX_FMT_NONE};
76 static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = {
77 PIX_FMT_XVMC_MPEG2_IDCT,
78 PIX_FMT_XVMC_MPEG2_MC,
79 PIX_FMT_NONE};
80
81 uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
82
83
84 #define INIT_2D_VLC_RL(rl, static_size)\
85 {\
86 static RL_VLC_ELEM rl_vlc_table[static_size];\
87 INIT_VLC_STATIC(&rl.vlc, TEX_VLC_BITS, rl.n + 2,\
88 &rl.table_vlc[0][1], 4, 2,\
89 &rl.table_vlc[0][0], 4, 2, static_size);\
90 \
91 rl.rl_vlc[0]= rl_vlc_table;\
92 init_2d_vlc_rl(&rl);\
93 }
94
95 static void init_2d_vlc_rl(RLTable *rl)
96 {
97 int i;
98
99 for(i=0; i<rl->vlc.table_size; i++){
100 int code= rl->vlc.table[i][0];
101 int len = rl->vlc.table[i][1];
102 int level, run;
103
104 if(len==0){ // illegal code
105 run= 65;
106 level= MAX_LEVEL;
107 }else if(len<0){ //more bits needed
108 run= 0;
109 level= code;
110 }else{
111 if(code==rl->n){ //esc
112 run= 65;
113 level= 0;
114 }else if(code==rl->n+1){ //eob
115 run= 0;
116 level= 127;
117 }else{
118 run= rl->table_run [code] + 1;
119 level= rl->table_level[code];
120 }
121 }
122 rl->rl_vlc[0][i].len= len;
123 rl->rl_vlc[0][i].level= level;
124 rl->rl_vlc[0][i].run= run;
125 }
126 }
127
128 void ff_mpeg12_common_init(MpegEncContext *s)
129 {
130
131 s->y_dc_scale_table=
132 s->c_dc_scale_table= mpeg2_dc_scale_table[s->intra_dc_precision];
133
134 }
135
136 void ff_mpeg1_clean_buffers(MpegEncContext *s){
137 s->last_dc[0] = 1 << (7 + s->intra_dc_precision);
138 s->last_dc[1] = s->last_dc[0];
139 s->last_dc[2] = s->last_dc[0];
140 memset(s->last_mv, 0, sizeof(s->last_mv));
141 }
142
143
144 /******************************************/
145 /* decoding */
146
147 static VLC dc_lum_vlc;
148 static VLC dc_chroma_vlc;
149 static VLC mv_vlc;
150 static VLC mbincr_vlc;
151 static VLC mb_ptype_vlc;
152 static VLC mb_btype_vlc;
153 static VLC mb_pat_vlc;
154
155 static void init_vlcs(void)
156 {
157 static int done = 0;
158
159 if (!done) {
160 done = 1;
161
162 INIT_VLC_STATIC(&dc_lum_vlc, DC_VLC_BITS, 12,
163 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
164 ff_mpeg12_vlc_dc_lum_code, 2, 2, 512);
165 INIT_VLC_STATIC(&dc_chroma_vlc, DC_VLC_BITS, 12,
166 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
167 ff_mpeg12_vlc_dc_chroma_code, 2, 2, 514);
168 INIT_VLC_STATIC(&mv_vlc, MV_VLC_BITS, 17,
169 &ff_mpeg12_mbMotionVectorTable[0][1], 2, 1,
170 &ff_mpeg12_mbMotionVectorTable[0][0], 2, 1, 518);
171 INIT_VLC_STATIC(&mbincr_vlc, MBINCR_VLC_BITS, 36,
172 &ff_mpeg12_mbAddrIncrTable[0][1], 2, 1,
173 &ff_mpeg12_mbAddrIncrTable[0][0], 2, 1, 538);
174 INIT_VLC_STATIC(&mb_pat_vlc, MB_PAT_VLC_BITS, 64,
175 &ff_mpeg12_mbPatTable[0][1], 2, 1,
176 &ff_mpeg12_mbPatTable[0][0], 2, 1, 512);
177
178 INIT_VLC_STATIC(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,
179 &table_mb_ptype[0][1], 2, 1,
180 &table_mb_ptype[0][0], 2, 1, 64);
181 INIT_VLC_STATIC(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,
182 &table_mb_btype[0][1], 2, 1,
183 &table_mb_btype[0][0], 2, 1, 64);
184 init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]);
185 init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]);
186
187 INIT_2D_VLC_RL(ff_rl_mpeg1, 680);
188 INIT_2D_VLC_RL(ff_rl_mpeg2, 674);
189 }
190 }
191
192 static inline int get_dmv(MpegEncContext *s)
193 {
194 if(get_bits1(&s->gb))
195 return 1 - (get_bits1(&s->gb) << 1);
196 else
197 return 0;
198 }
199
200 static inline int get_qscale(MpegEncContext *s)
201 {
202 int qscale = get_bits(&s->gb, 5);
203 if (s->q_scale_type) {
204 return non_linear_qscale[qscale];
205 } else {
206 return qscale << 1;
207 }
208 }
209
210 /* motion type (for mpeg2) */
211 #define MT_FIELD 1
212 #define MT_FRAME 2
213 #define MT_16X8 2
214 #define MT_DMV 3
215
216 static int mpeg_decode_mb(MpegEncContext *s,
217 DCTELEM block[12][64])
218 {
219 int i, j, k, cbp, val, mb_type, motion_type;
220 const int mb_block_count = 4 + (1<< s->chroma_format);
221
222 dprintf(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
223
224 assert(s->mb_skipped==0);
225
226 if (s->mb_skip_run-- != 0) {
227 if (s->pict_type == FF_P_TYPE) {
228 s->mb_skipped = 1;
229 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
230 } else {
231 int mb_type;
232
233 if(s->mb_x)
234 mb_type= s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1];
235 else
236 mb_type= s->current_picture.mb_type[ s->mb_width + (s->mb_y-1)*s->mb_stride - 1]; // FIXME not sure if this is allowed in mpeg at all,
237 if(IS_INTRA(mb_type))
238 return -1;
239
240 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]=
241 mb_type | MB_TYPE_SKIP;
242 // assert(s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride - 1]&(MB_TYPE_16x16|MB_TYPE_16x8));
243
244 if((s->mv[0][0][0]|s->mv[0][0][1]|s->mv[1][0][0]|s->mv[1][0][1])==0)
245 s->mb_skipped = 1;
246 }
247
248 return 0;
249 }
250
251 switch(s->pict_type) {
252 default:
253 case FF_I_TYPE:
254 if (get_bits1(&s->gb) == 0) {
255 if (get_bits1(&s->gb) == 0){
256 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in I Frame at %d %d\n", s->mb_x, s->mb_y);
257 return -1;
258 }
259 mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
260 } else {
261 mb_type = MB_TYPE_INTRA;
262 }
263 break;
264 case FF_P_TYPE:
265 mb_type = get_vlc2(&s->gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
266 if (mb_type < 0){
267 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
268 return -1;
269 }
270 mb_type = ptype2mb_type[ mb_type ];
271 break;
272 case FF_B_TYPE:
273 mb_type = get_vlc2(&s->gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
274 if (mb_type < 0){
275 av_log(s->avctx, AV_LOG_ERROR, "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
276 return -1;
277 }
278 mb_type = btype2mb_type[ mb_type ];
279 break;
280 }
281 dprintf(s->avctx, "mb_type=%x\n", mb_type);
282 // motion_type = 0; /* avoid warning */
283 if (IS_INTRA(mb_type)) {
284 s->dsp.clear_blocks(s->block[0]);
285
286 if(!s->chroma_y_shift){
287 s->dsp.clear_blocks(s->block[6]);
288 }
289
290 /* compute dct type */
291 if (s->picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var?
292 !s->frame_pred_frame_dct) {
293 s->interlaced_dct = get_bits1(&s->gb);
294 }
295
296 if (IS_QUANT(mb_type))
297 s->qscale = get_qscale(s);
298
299 if (s->concealment_motion_vectors) {
300 /* just parse them */
301 if (s->picture_structure != PICT_FRAME)
302 skip_bits1(&s->gb); /* field select */
303
304 s->mv[0][0][0]= s->last_mv[0][0][0]= s->last_mv[0][1][0] =
305 mpeg_decode_motion(s, s->mpeg_f_code[0][0], s->last_mv[0][0][0]);
306 s->mv[0][0][1]= s->last_mv[0][0][1]= s->last_mv[0][1][1] =
307 mpeg_decode_motion(s, s->mpeg_f_code[0][1], s->last_mv[0][0][1]);
308
309 skip_bits1(&s->gb); /* marker */
310 }else
311 memset(s->last_mv, 0, sizeof(s->last_mv)); /* reset mv prediction */
312 s->mb_intra = 1;
313 #ifdef HAVE_XVMC
314 //one 1 we memcpy blocks in xvmcvideo
315 if(s->avctx->xvmc_acceleration > 1){
316 XVMC_pack_pblocks(s,-1);//inter are always full blocks
317 if(s->swap_uv){
318 exchange_uv(s);
319 }
320 }
321 #endif
322
323 if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
324 if(s->flags2 & CODEC_FLAG2_FAST){
325 for(i=0;i<6;i++) {
326 mpeg2_fast_decode_block_intra(s, s->pblocks[i], i);
327 }
328 }else{
329 for(i=0;i<mb_block_count;i++) {
330 if (mpeg2_decode_block_intra(s, s->pblocks[i], i) < 0)
331 return -1;
332 }
333 }
334 } else {
335 for(i=0;i<6;i++) {
336 if (mpeg1_decode_block_intra(s, s->pblocks[i], i) < 0)
337 return -1;
338 }
339 }
340 } else {
341 if (mb_type & MB_TYPE_ZERO_MV){
342 assert(mb_type & MB_TYPE_CBP);
343
344 s->mv_dir = MV_DIR_FORWARD;
345 if(s->picture_structure == PICT_FRAME){
346 if(!s->frame_pred_frame_dct)
347 s->interlaced_dct = get_bits1(&s->gb);
348 s->mv_type = MV_TYPE_16X16;
349 }else{
350 s->mv_type = MV_TYPE_FIELD;
351 mb_type |= MB_TYPE_INTERLACED;
352 s->field_select[0][0]= s->picture_structure - 1;
353 }
354
355 if (IS_QUANT(mb_type))
356 s->qscale = get_qscale(s);
357
358 s->last_mv[0][0][0] = 0;
359 s->last_mv[0][0][1] = 0;
360 s->last_mv[0][1][0] = 0;
361 s->last_mv[0][1][1] = 0;
362 s->mv[0][0][0] = 0;
363 s->mv[0][0][1] = 0;
364 }else{
365 assert(mb_type & MB_TYPE_L0L1);
366 //FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
367 /* get additional motion vector type */
368 if (s->frame_pred_frame_dct)
369 motion_type = MT_FRAME;
370 else{
371 motion_type = get_bits(&s->gb, 2);
372 if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
373 s->interlaced_dct = get_bits1(&s->gb);
374 }
375
376 if (IS_QUANT(mb_type))
377 s->qscale = get_qscale(s);
378
379 /* motion vectors */
380 s->mv_dir= (mb_type>>13)&3;
381 dprintf(s->avctx, "motion_type=%d\n", motion_type);
382 switch(motion_type) {
383 case MT_FRAME: /* or MT_16X8 */
384 if (s->picture_structure == PICT_FRAME) {
385 mb_type |= MB_TYPE_16x16;
386 s->mv_type = MV_TYPE_16X16;
387 for(i=0;i<2;i++) {
388 if (USES_LIST(mb_type, i)) {
389 /* MT_FRAME */
390 s->mv[i][0][0]= s->last_mv[i][0][0]= s->last_mv[i][1][0] =
391 mpeg_decode_motion(s, s->mpeg_f_code[i][0], s->last_mv[i][0][0]);
392 s->mv[i][0][1]= s->last_mv[i][0][1]= s->last_mv[i][1][1] =
393 mpeg_decode_motion(s, s->mpeg_f_code[i][1], s->last_mv[i][0][1]);
394 /* full_pel: only for mpeg1 */
395 if (s->full_pel[i]){
396 s->mv[i][0][0] <<= 1;
397 s->mv[i][0][1] <<= 1;
398 }
399 }
400 }
401 } else {
402 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
403 s->mv_type = MV_TYPE_16X8;
404 for(i=0;i<2;i++) {
405 if (USES_LIST(mb_type, i)) {
406 /* MT_16X8 */
407 for(j=0;j<2;j++) {
408 s->field_select[i][j] = get_bits1(&s->gb);
409 for(k=0;k<2;k++) {
410 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
411 s->last_mv[i][j][k]);
412 s->last_mv[i][j][k] = val;
413 s->mv[i][j][k] = val;
414 }
415 }
416 }
417 }
418 }
419 break;
420 case MT_FIELD:
421 s->mv_type = MV_TYPE_FIELD;
422 if (s->picture_structure == PICT_FRAME) {
423 mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
424 for(i=0;i<2;i++) {
425 if (USES_LIST(mb_type, i)) {
426 for(j=0;j<2;j++) {
427 s->field_select[i][j] = get_bits1(&s->gb);
428 val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
429 s->last_mv[i][j][0]);
430 s->last_mv[i][j][0] = val;
431 s->mv[i][j][0] = val;
432 dprintf(s->avctx, "fmx=%d\n", val);
433 val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
434 s->last_mv[i][j][1] >> 1);
435 s->last_mv[i][j][1] = val << 1;
436 s->mv[i][j][1] = val;
437 dprintf(s->avctx, "fmy=%d\n", val);
438 }
439 }
440 }
441 } else {
442 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
443 for(i=0;i<2;i++) {
444 if (USES_LIST(mb_type, i)) {
445 s->field_select[i][0] = get_bits1(&s->gb);
446 for(k=0;k<2;k++) {
447 val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
448 s->last_mv[i][0][k]);
449 s->last_mv[i][0][k] = val;
450 s->last_mv[i][1][k] = val;
451 s->mv[i][0][k] = val;
452 }
453 }
454 }
455 }
456 break;
457 case MT_DMV:
458 s->mv_type = MV_TYPE_DMV;
459 for(i=0;i<2;i++) {
460 if (USES_LIST(mb_type, i)) {
461 int dmx, dmy, mx, my, m;
462 mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
463 s->last_mv[i][0][0]);
464 s->last_mv[i][0][0] = mx;
465 s->last_mv[i][1][0] = mx;
466 dmx = get_dmv(s);
467 my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
468 s->last_mv[i][0][1] >> 1);
469 dmy = get_dmv(s);
470
471
472 s->last_mv[i][0][1] = my<<1;
473 s->last_mv[i][1][1] = my<<1;
474
475 s->mv[i][0][0] = mx;
476 s->mv[i][0][1] = my;
477 s->mv[i][1][0] = mx;//not used
478 s->mv[i][1][1] = my;//not used
479
480 if (s->picture_structure == PICT_FRAME) {
481 mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
482
483 //m = 1 + 2 * s->top_field_first;
484 m = s->top_field_first ? 1 : 3;
485
486 /* top -> top pred */
487 s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
488 s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
489 m = 4 - m;
490 s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
491 s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
492 } else {
493 mb_type |= MB_TYPE_16x16;
494
495 s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
496 s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
497 if(s->picture_structure == PICT_TOP_FIELD)
498 s->mv[i][2][1]--;
499 else
500 s->mv[i][2][1]++;
501 }
502 }
503 }
504 break;
505 default:
506 av_log(s->avctx, AV_LOG_ERROR, "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
507 return -1;
508 }
509 }
510
511 s->mb_intra = 0;
512 if (HAS_CBP(mb_type)) {
513 s->dsp.clear_blocks(s->block[0]);
514
515 cbp = get_vlc2(&s->gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
516 if(mb_block_count > 6){
517 cbp<<= mb_block_count-6;
518 cbp |= get_bits(&s->gb, mb_block_count-6);
519 s->dsp.clear_blocks(s->block[6]);
520 }
521 if (cbp <= 0){
522 av_log(s->avctx, AV_LOG_ERROR, "invalid cbp at %d %d\n", s->mb_x, s->mb_y);
523 return -1;
524 }
525
526 #ifdef HAVE_XVMC
527 //on 1 we memcpy blocks in xvmcvideo
528 if(s->avctx->xvmc_acceleration > 1){
529 XVMC_pack_pblocks(s,cbp);
530 if(s->swap_uv){
531 exchange_uv(s);
532 }
533 }
534 #endif
535
536 if (s->codec_id == CODEC_ID_MPEG2VIDEO) {
537 if(s->flags2 & CODEC_FLAG2_FAST){
538 for(i=0;i<6;i++) {
539 if(cbp & 32) {
540 mpeg2_fast_decode_block_non_intra(s, s->pblocks[i], i);
541 } else {
542 s->block_last_index[i] = -1;
543 }
544 cbp+=cbp;
545 }
546 }else{
547 cbp<<= 12-mb_block_count;
548
549 for(i=0;i<mb_block_count;i++) {
550 if ( cbp & (1<<11) ) {
551 if (mpeg2_decode_block_non_intra(s, s->pblocks[i], i) < 0)
552 return -1;
553 } else {
554 s->block_last_index[i] = -1;
555 }
556 cbp+=cbp;
557 }
558 }
559 } else {
560 if(s->flags2 & CODEC_FLAG2_FAST){
561 for(i=0;i<6;i++) {
562 if (cbp & 32) {
563 mpeg1_fast_decode_block_inter(s, s->pblocks[i], i);
564 } else {
565 s->block_last_index[i] = -1;
566 }
567 cbp+=cbp;
568 }
569 }else{
570 for(i=0;i<6;i++) {
571 if (cbp & 32) {
572 if (mpeg1_decode_block_inter(s, s->pblocks[i], i) < 0)
573 return -1;
574 } else {
575 s->block_last_index[i] = -1;
576 }
577 cbp+=cbp;
578 }
579 }
580 }
581 }else{
582 for(i=0;i<12;i++)
583 s->block_last_index[i] = -1;
584 }
585 }
586
587 s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]= mb_type;
588
589 return 0;
590 }
591
592 /* as h263, but only 17 codes */
593 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
594 {
595 int code, sign, val, l, shift;
596
597 code = get_vlc2(&s->gb, mv_vlc.table, MV_VLC_BITS, 2);
598 if (code == 0) {
599 return pred;
600 }
601 if (code < 0) {
602 return 0xffff;
603 }
604
605 sign = get_bits1(&s->gb);
606 shift = fcode - 1;
607 val = code;
608 if (shift) {
609 val = (val - 1) << shift;
610 val |= get_bits(&s->gb, shift);
611 val++;
612 }
613 if (sign)
614 val = -val;
615 val += pred;
616
617 /* modulo decoding */
618 l= INT_BIT - 5 - shift;
619 val = (val<<l)>>l;
620 return val;
621 }
622
623 static inline int decode_dc(GetBitContext *gb, int component)
624 {
625 int code, diff;
626
627 if (component == 0) {
628 code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);
629 } else {
630 code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);
631 }
632 if (code < 0){
633 av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
634 return 0xffff;
635 }
636 if (code == 0) {
637 diff = 0;
638 } else {
639 diff = get_xbits(gb, code);
640 }
641 return diff;
642 }
643
644 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
645 DCTELEM *block,
646 int n)
647 {
648 int level, dc, diff, i, j, run;
649 int component;
650 RLTable *rl = &ff_rl_mpeg1;
651 uint8_t * const scantable= s->intra_scantable.permutated;
652 const uint16_t *quant_matrix= s->intra_matrix;
653 const int qscale= s->qscale;
654
655 /* DC coef */
656 component = (n <= 3 ? 0 : n - 4 + 1);
657 diff = decode_dc(&s->gb, component);
658 if (diff >= 0xffff)
659 return -1;
660 dc = s->last_dc[component];
661 dc += diff;
662 s->last_dc[component] = dc;
663 block[0] = dc<<3;
664 dprintf(s->avctx, "dc=%d diff=%d\n", dc, diff);
665 i = 0;
666 {
667 OPEN_READER(re, &s->gb);
668 /* now quantify & encode AC coefs */
669 for(;;) {
670 UPDATE_CACHE(re, &s->gb);
671 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
672
673 if(level == 127){
674 break;
675 } else if(level != 0) {
676 i += run;
677 j = scantable[i];
678 level= (level*qscale*quant_matrix[j])>>4;
679 level= (level-1)|1;
680 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
681 LAST_SKIP_BITS(re, &s->gb, 1);
682 } else {
683 /* escape */
684 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
685 UPDATE_CACHE(re, &s->gb);
686 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
687 if (level == -128) {
688 level = SHOW_UBITS(re, &s->gb, 8) - 256; LAST_SKIP_BITS(re, &s->gb, 8);
689 } else if (level == 0) {
690 level = SHOW_UBITS(re, &s->gb, 8) ; LAST_SKIP_BITS(re, &s->gb, 8);
691 }
692 i += run;
693 j = scantable[i];
694 if(level<0){
695 level= -level;
696 level= (level*qscale*quant_matrix[j])>>4;
697 level= (level-1)|1;
698 level= -level;
699 }else{
700 level= (level*qscale*quant_matrix[j])>>4;
701 level= (level-1)|1;
702 }
703 }
704 if (i > 63){
705 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
706 return -1;
707 }
708
709 block[j] = level;
710 }
711 CLOSE_READER(re, &s->gb);
712 }
713 s->block_last_index[n] = i;
714 return 0;
715 }
716
717 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
718 DCTELEM *block,
719 int n)
720 {
721 int level, i, j, run;
722 RLTable *rl = &ff_rl_mpeg1;
723 uint8_t * const scantable= s->intra_scantable.permutated;
724 const uint16_t *quant_matrix= s->inter_matrix;
725 const int qscale= s->qscale;
726
727 {
728 OPEN_READER(re, &s->gb);
729 i = -1;
730 /* special case for the first coef. no need to add a second vlc table */
731 UPDATE_CACHE(re, &s->gb);
732 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
733 level= (3*qscale*quant_matrix[0])>>5;
734 level= (level-1)|1;
735 if(GET_CACHE(re, &s->gb)&0x40000000)
736 level= -level;
737 block[0] = level;
738 i++;
739 SKIP_BITS(re, &s->gb, 2);
740 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
741 goto end;
742 }
743 #if MIN_CACHE_BITS < 19
744 UPDATE_CACHE(re, &s->gb);
745 #endif
746 /* now quantify & encode AC coefs */
747 for(;;) {
748 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
749
750 if(level != 0) {
751 i += run;
752 j = scantable[i];
753 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
754 level= (level-1)|1;
755 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
756 SKIP_BITS(re, &s->gb, 1);
757 } else {
758 /* escape */
759 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
760 UPDATE_CACHE(re, &s->gb);
761 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
762 if (level == -128) {
763 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
764 } else if (level == 0) {
765 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
766 }
767 i += run;
768 j = scantable[i];
769 if(level<0){
770 level= -level;
771 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
772 level= (level-1)|1;
773 level= -level;
774 }else{
775 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
776 level= (level-1)|1;
777 }
778 }
779 if (i > 63){
780 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
781 return -1;
782 }
783
784 block[j] = level;
785 #if MIN_CACHE_BITS < 19
786 UPDATE_CACHE(re, &s->gb);
787 #endif
788 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
789 break;
790 #if MIN_CACHE_BITS >= 19
791 UPDATE_CACHE(re, &s->gb);
792 #endif
793 }
794 end:
795 LAST_SKIP_BITS(re, &s->gb, 2);
796 CLOSE_READER(re, &s->gb);
797 }
798 s->block_last_index[n] = i;
799 return 0;
800 }
801
802 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s, DCTELEM *block, int n)
803 {
804 int level, i, j, run;
805 RLTable *rl = &ff_rl_mpeg1;
806 uint8_t * const scantable= s->intra_scantable.permutated;
807 const int qscale= s->qscale;
808
809 {
810 OPEN_READER(re, &s->gb);
811 i = -1;
812 /* special case for the first coef. no need to add a second vlc table */
813 UPDATE_CACHE(re, &s->gb);
814 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
815 level= (3*qscale)>>1;
816 level= (level-1)|1;
817 if(GET_CACHE(re, &s->gb)&0x40000000)
818 level= -level;
819 block[0] = level;
820 i++;
821 SKIP_BITS(re, &s->gb, 2);
822 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
823 goto end;
824 }
825 #if MIN_CACHE_BITS < 19
826 UPDATE_CACHE(re, &s->gb);
827 #endif
828
829 /* now quantify & encode AC coefs */
830 for(;;) {
831 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
832
833 if(level != 0) {
834 i += run;
835 j = scantable[i];
836 level= ((level*2+1)*qscale)>>1;
837 level= (level-1)|1;
838 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
839 SKIP_BITS(re, &s->gb, 1);
840 } else {
841 /* escape */
842 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
843 UPDATE_CACHE(re, &s->gb);
844 level = SHOW_SBITS(re, &s->gb, 8); SKIP_BITS(re, &s->gb, 8);
845 if (level == -128) {
846 level = SHOW_UBITS(re, &s->gb, 8) - 256; SKIP_BITS(re, &s->gb, 8);
847 } else if (level == 0) {
848 level = SHOW_UBITS(re, &s->gb, 8) ; SKIP_BITS(re, &s->gb, 8);
849 }
850 i += run;
851 j = scantable[i];
852 if(level<0){
853 level= -level;
854 level= ((level*2+1)*qscale)>>1;
855 level= (level-1)|1;
856 level= -level;
857 }else{
858 level= ((level*2+1)*qscale)>>1;
859 level= (level-1)|1;
860 }
861 }
862
863 block[j] = level;
864 #if MIN_CACHE_BITS < 19
865 UPDATE_CACHE(re, &s->gb);
866 #endif
867 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
868 break;
869 #if MIN_CACHE_BITS >= 19
870 UPDATE_CACHE(re, &s->gb);
871 #endif
872 }
873 end:
874 LAST_SKIP_BITS(re, &s->gb, 2);
875 CLOSE_READER(re, &s->gb);
876 }
877 s->block_last_index[n] = i;
878 return 0;
879 }
880
881
882 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
883 DCTELEM *block,
884 int n)
885 {
886 int level, i, j, run;
887 RLTable *rl = &ff_rl_mpeg1;
888 uint8_t * const scantable= s->intra_scantable.permutated;
889 const uint16_t *quant_matrix;
890 const int qscale= s->qscale;
891 int mismatch;
892
893 mismatch = 1;
894
895 {
896 OPEN_READER(re, &s->gb);
897 i = -1;
898 if (n < 4)
899 quant_matrix = s->inter_matrix;
900 else
901 quant_matrix = s->chroma_inter_matrix;
902
903 /* special case for the first coef. no need to add a second vlc table */
904 UPDATE_CACHE(re, &s->gb);
905 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
906 level= (3*qscale*quant_matrix[0])>>5;
907 if(GET_CACHE(re, &s->gb)&0x40000000)
908 level= -level;
909 block[0] = level;
910 mismatch ^= level;
911 i++;
912 SKIP_BITS(re, &s->gb, 2);
913 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
914 goto end;
915 }
916 #if MIN_CACHE_BITS < 19
917 UPDATE_CACHE(re, &s->gb);
918 #endif
919
920 /* now quantify & encode AC coefs */
921 for(;;) {
922 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
923
924 if(level != 0) {
925 i += run;
926 j = scantable[i];
927 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
928 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
929 SKIP_BITS(re, &s->gb, 1);
930 } else {
931 /* escape */
932 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
933 UPDATE_CACHE(re, &s->gb);
934 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
935
936 i += run;
937 j = scantable[i];
938 if(level<0){
939 level= ((-level*2+1)*qscale*quant_matrix[j])>>5;
940 level= -level;
941 }else{
942 level= ((level*2+1)*qscale*quant_matrix[j])>>5;
943 }
944 }
945 if (i > 63){
946 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
947 return -1;
948 }
949
950 mismatch ^= level;
951 block[j] = level;
952 #if MIN_CACHE_BITS < 19
953 UPDATE_CACHE(re, &s->gb);
954 #endif
955 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
956 break;
957 #if MIN_CACHE_BITS >= 19
958 UPDATE_CACHE(re, &s->gb);
959 #endif
960 }
961 end:
962 LAST_SKIP_BITS(re, &s->gb, 2);
963 CLOSE_READER(re, &s->gb);
964 }
965 block[63] ^= (mismatch & 1);
966
967 s->block_last_index[n] = i;
968 return 0;
969 }
970
971 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
972 DCTELEM *block,
973 int n)
974 {
975 int level, i, j, run;
976 RLTable *rl = &ff_rl_mpeg1;
977 uint8_t * const scantable= s->intra_scantable.permutated;
978 const int qscale= s->qscale;
979 OPEN_READER(re, &s->gb);
980 i = -1;
981
982 /* special case for the first coef. no need to add a second vlc table */
983 UPDATE_CACHE(re, &s->gb);
984 if (((int32_t)GET_CACHE(re, &s->gb)) < 0) {
985 level= (3*qscale)>>1;
986 if(GET_CACHE(re, &s->gb)&0x40000000)
987 level= -level;
988 block[0] = level;
989 i++;
990 SKIP_BITS(re, &s->gb, 2);
991 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
992 goto end;
993 }
994 #if MIN_CACHE_BITS < 19
995 UPDATE_CACHE(re, &s->gb);
996 #endif
997
998 /* now quantify & encode AC coefs */
999 for(;;) {
1000 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1001
1002 if(level != 0) {
1003 i += run;
1004 j = scantable[i];
1005 level= ((level*2+1)*qscale)>>1;
1006 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1007 SKIP_BITS(re, &s->gb, 1);
1008 } else {
1009 /* escape */
1010 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1011 UPDATE_CACHE(re, &s->gb);
1012 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1013
1014 i += run;
1015 j = scantable[i];
1016 if(level<0){
1017 level= ((-level*2+1)*qscale)>>1;
1018 level= -level;
1019 }else{
1020 level= ((level*2+1)*qscale)>>1;
1021 }
1022 }
1023
1024 block[j] = level;
1025 #if MIN_CACHE_BITS < 19
1026 UPDATE_CACHE(re, &s->gb);
1027 #endif
1028 if(((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
1029 break;
1030 #if MIN_CACHE_BITS >=19
1031 UPDATE_CACHE(re, &s->gb);
1032 #endif
1033 }
1034 end:
1035 LAST_SKIP_BITS(re, &s->gb, 2);
1036 CLOSE_READER(re, &s->gb);
1037 s->block_last_index[n] = i;
1038 return 0;
1039 }
1040
1041
1042 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
1043 DCTELEM *block,
1044 int n)
1045 {
1046 int level, dc, diff, i, j, run;
1047 int component;
1048 RLTable *rl;
1049 uint8_t * const scantable= s->intra_scantable.permutated;
1050 const uint16_t *quant_matrix;
1051 const int qscale= s->qscale;
1052 int mismatch;
1053
1054 /* DC coef */
1055 if (n < 4){
1056 quant_matrix = s->intra_matrix;
1057 component = 0;
1058 }else{
1059 quant_matrix = s->chroma_intra_matrix;
1060 component = (n&1) + 1;
1061 }
1062 diff = decode_dc(&s->gb, component);
1063 if (diff >= 0xffff)
1064 return -1;
1065 dc = s->last_dc[component];
1066 dc += diff;
1067 s->last_dc[component] = dc;
1068 block[0] = dc << (3 - s->intra_dc_precision);
1069 dprintf(s->avctx, "dc=%d\n", block[0]);
1070 mismatch = block[0] ^ 1;
1071 i = 0;
1072 if (s->intra_vlc_format)
1073 rl = &ff_rl_mpeg2;
1074 else
1075 rl = &ff_rl_mpeg1;
1076
1077 {
1078 OPEN_READER(re, &s->gb);
1079 /* now quantify & encode AC coefs */
1080 for(;;) {
1081 UPDATE_CACHE(re, &s->gb);
1082 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1083
1084 if(level == 127){
1085 break;
1086 } else if(level != 0) {
1087 i += run;
1088 j = scantable[i];
1089 level= (level*qscale*quant_matrix[j])>>4;
1090 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1091 LAST_SKIP_BITS(re, &s->gb, 1);
1092 } else {
1093 /* escape */
1094 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1095 UPDATE_CACHE(re, &s->gb);
1096 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1097 i += run;
1098 j = scantable[i];
1099 if(level<0){
1100 level= (-level*qscale*quant_matrix[j])>>4;
1101 level= -level;
1102 }else{
1103 level= (level*qscale*quant_matrix[j])>>4;
1104 }
1105 }
1106 if (i > 63){
1107 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1108 return -1;
1109 }
1110
1111 mismatch^= level;
1112 block[j] = level;
1113 }
1114 CLOSE_READER(re, &s->gb);
1115 }
1116 block[63]^= mismatch&1;
1117
1118 s->block_last_index[n] = i;
1119 return 0;
1120 }
1121
1122 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
1123 DCTELEM *block,
1124 int n)
1125 {
1126 int level, dc, diff, j, run;
1127 int component;
1128 RLTable *rl;
1129 uint8_t * scantable= s->intra_scantable.permutated;
1130 const uint16_t *quant_matrix;
1131 const int qscale= s->qscale;
1132
1133 /* DC coef */
1134 if (n < 4){
1135 quant_matrix = s->intra_matrix;
1136 component = 0;
1137 }else{
1138 quant_matrix = s->chroma_intra_matrix;
1139 component = (n&1) + 1;
1140 }
1141 diff = decode_dc(&s->gb, component);
1142 if (diff >= 0xffff)
1143 return -1;
1144 dc = s->last_dc[component];
1145 dc += diff;
1146 s->last_dc[component] = dc;
1147 block[0] = dc << (3 - s->intra_dc_precision);
1148 if (s->intra_vlc_format)
1149 rl = &ff_rl_mpeg2;
1150 else
1151 rl = &ff_rl_mpeg1;
1152
1153 {
1154 OPEN_READER(re, &s->gb);
1155 /* now quantify & encode AC coefs */
1156 for(;;) {
1157 UPDATE_CACHE(re, &s->gb);
1158 GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
1159
1160 if(level == 127){
1161 break;
1162 } else if(level != 0) {
1163 scantable += run;
1164 j = *scantable;
1165 level= (level*qscale*quant_matrix[j])>>4;
1166 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1167 LAST_SKIP_BITS(re, &s->gb, 1);
1168 } else {
1169 /* escape */
1170 run = SHOW_UBITS(re, &s->gb, 6)+1; LAST_SKIP_BITS(re, &s->gb, 6);
1171 UPDATE_CACHE(re, &s->gb);
1172 level = SHOW_SBITS(re, &s->gb, 12); SKIP_BITS(re, &s->gb, 12);
1173 scantable += run;
1174 j = *scantable;
1175 if(level<0){
1176 level= (-level*qscale*quant_matrix[j])>>4;
1177 level= -level;
1178 }else{
1179 level= (level*qscale*quant_matrix[j])>>4;
1180 }
1181 }
1182
1183 block[j] = level;
1184 }
1185 CLOSE_READER(re, &s->gb);
1186 }
1187
1188 s->block_last_index[n] = scantable - s->intra_scantable.permutated;
1189 return 0;
1190 }
1191
1192 typedef struct Mpeg1Context {
1193 MpegEncContext mpeg_enc_ctx;
1194 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
1195 int repeat_field; /* true if we must repeat the field */
1196 AVPanScan pan_scan; /** some temporary storage for the panscan */
1197 int slice_count;
1198 int swap_uv;//indicate VCR2
1199 int save_aspect_info;
1200 int save_width, save_height;
1201 AVRational frame_rate_ext; ///< MPEG-2 specific framerate modificator
1202
1203 } Mpeg1Context;
1204
1205 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1206 {
1207 Mpeg1Context *s = avctx->priv_data;
1208 MpegEncContext *s2 = &s->mpeg_enc_ctx;
1209 int i;
1210
1211 //we need some parmutation to store
1212 //matrixes, until MPV_common_init()
1213 //set the real permutatuon
1214 for(i=0;i<64;i++)
1215 s2->dsp.idct_permutation[i]=i;
1216
1217 MPV_decode_defaults(s2);
1218
1219 s->mpeg_enc_ctx.avctx= avctx;
1220 s->mpeg_enc_ctx.flags= avctx->flags;
1221 s->mpeg_enc_ctx.flags2= avctx->flags2;
1222 ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1223 init_vlcs();
1224
1225 s->mpeg_enc_ctx_allocated = 0;
1226 s->mpeg_enc_ctx.picture_number = 0;
1227 s->repeat_field = 0;
1228 s->mpeg_enc_ctx.codec_id= avctx->codec->id;
1229 return 0;
1230 }
1231
1232 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1233 const uint8_t *new_perm){
1234 uint16_t temp_matrix[64];
1235 int i;
1236
1237 memcpy(temp_matrix,matrix,64*sizeof(uint16_t));
1238
1239 for(i=0;i<64;i++){
1240 matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1241 }
1242 }
1243
1244 //Call this function when we know all parameters
1245 //it may be called in different places for mpeg1 and mpeg2
1246 static int mpeg_decode_postinit(AVCodecContext *avctx){
1247 Mpeg1Context *s1 = avctx->priv_data;
1248 MpegEncContext *s = &s1->mpeg_enc_ctx;
1249 uint8_t old_permutation[64];
1250
1251 if (
1252 (s1->mpeg_enc_ctx_allocated == 0)||
1253 avctx->coded_width != s->width ||
1254 avctx->coded_height != s->height||
1255 s1->save_width != s->width ||
1256 s1->save_height != s->height ||
1257 s1->save_aspect_info != s->aspect_ratio_info||
1258 0)
1259 {
1260
1261 if (s1->mpeg_enc_ctx_allocated) {
1262 ParseContext pc= s->parse_context;
1263 s->parse_context.buffer=0;
1264 MPV_common_end(s);
1265 s->parse_context= pc;
1266 }
1267
1268 if( (s->width == 0 )||(s->height == 0))
1269 return -2;
1270
1271 avcodec_set_dimensions(avctx, s->width, s->height);
1272 avctx->bit_rate = s->bit_rate;
1273 s1->save_aspect_info = s->aspect_ratio_info;
1274 s1->save_width = s->width;
1275 s1->save_height = s->height;
1276
1277 //low_delay may be forced, in this case we will have B frames
1278 //that behave like P frames
1279 avctx->has_b_frames = !(s->low_delay);
1280
1281 if(avctx->sub_id==1){//s->codec_id==avctx->codec_id==CODEC_ID
1282 //mpeg1 fps
1283 avctx->time_base.den= ff_frame_rate_tab[s->frame_rate_index].num;
1284 avctx->time_base.num= ff_frame_rate_tab[s->frame_rate_index].den;
1285 //mpeg1 aspect
1286 avctx->sample_aspect_ratio= av_d2q(
1287 1.0/ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1288
1289 }else{//mpeg2
1290 //mpeg2 fps
1291 av_reduce(
1292 &s->avctx->time_base.den,
1293 &s->avctx->time_base.num,
1294 ff_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1295 ff_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1296 1<<30);
1297 //mpeg2 aspect
1298 if(s->aspect_ratio_info > 1){
1299 if( (s1->pan_scan.width == 0 )||(s1->pan_scan.height == 0) ){
1300 s->avctx->sample_aspect_ratio=
1301 av_div_q(
1302 ff_mpeg2_aspect[s->aspect_ratio_info],
1303 (AVRational){s->width, s->height}
1304 );
1305 }else{
1306 s->avctx->sample_aspect_ratio=
1307 av_div_q(
1308 ff_mpeg2_aspect[s->aspect_ratio_info],
1309 (AVRational){s1->pan_scan.width, s1->pan_scan.height}
1310 );
1311 }
1312 }else{
1313 s->avctx->sample_aspect_ratio=
1314 ff_mpeg2_aspect[s->aspect_ratio_info];
1315 }
1316 }//mpeg2
1317
1318 if(avctx->xvmc_acceleration){
1319 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
1320 }else{
1321 if(s->chroma_format < 2){
1322 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
1323 }else
1324 if(s->chroma_format == 2){
1325 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_422);
1326 }else
1327 if(s->chroma_format > 2){
1328 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_444);
1329 }
1330 }
1331 //until then pix_fmt may be changed right after codec init
1332 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
1333 if( avctx->idct_algo == FF_IDCT_AUTO )
1334 avctx->idct_algo = FF_IDCT_SIMPLE;
1335
1336 //quantization matrixes may need reordering
1337 //if dct permutation is changed
1338 memcpy(old_permutation,s->dsp.idct_permutation,64*sizeof(uint8_t));
1339
1340 if (MPV_common_init(s) < 0)
1341 return -2;
1342
1343 quant_matrix_rebuild(s->intra_matrix, old_permutation,s->dsp.idct_permutation);
1344 quant_matrix_rebuild(s->inter_matrix, old_permutation,s->dsp.idct_permutation);
1345 quant_matrix_rebuild(s->chroma_intra_matrix,old_permutation,s->dsp.idct_permutation);
1346 quant_matrix_rebuild(s->chroma_inter_matrix,old_permutation,s->dsp.idct_permutation);
1347
1348 s1->mpeg_enc_ctx_allocated = 1;
1349 }
1350 return 0;
1351 }
1352
1353 static int mpeg1_decode_picture(AVCodecContext *avctx,
1354 const uint8_t *buf, int buf_size)
1355 {
1356 Mpeg1Context *s1 = avctx->priv_data;
1357 MpegEncContext *s = &s1->mpeg_enc_ctx;
1358 int ref, f_code, vbv_delay;
1359
1360 if(mpeg_decode_postinit(s->avctx) < 0)
1361 return -2;
1362
1363 init_get_bits(&s->gb, buf, buf_size*8);
1364
1365 ref = get_bits(&s->gb, 10); /* temporal ref */
1366 s->pict_type = get_bits(&s->gb, 3);
1367 if(s->pict_type == 0 || s->pict_type > 3)
1368 return -1;
1369
1370 vbv_delay= get_bits(&s->gb, 16);
1371 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) {
1372 s->full_pel[0] = get_bits1(&s->gb);
1373 f_code = get_bits(&s->gb, 3);
1374 if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
1375 return -1;
1376 s->mpeg_f_code[0][0] = f_code;
1377 s->mpeg_f_code[0][1] = f_code;
1378 }
1379 if (s->pict_type == FF_B_TYPE) {
1380 s->full_pel[1] = get_bits1(&s->gb);
1381 f_code = get_bits(&s->gb, 3);
1382 if (f_code == 0 && avctx->error_resilience >= FF_ER_COMPLIANT)
1383 return -1;
1384 s->mpeg_f_code[1][0] = f_code;
1385 s->mpeg_f_code[1][1] = f_code;
1386 }
1387 s->current_picture.pict_type= s->pict_type;
1388 s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
1389
1390 if(avctx->debug & FF_DEBUG_PICT_INFO)
1391 av_log(avctx, AV_LOG_DEBUG, "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1392
1393 s->y_dc_scale = 8;
1394 s->c_dc_scale = 8;
1395 s->first_slice = 1;
1396 return 0;
1397 }
1398
1399 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1400 {
1401 MpegEncContext *s= &s1->mpeg_enc_ctx;
1402 int horiz_size_ext, vert_size_ext;
1403 int bit_rate_ext;
1404
1405 skip_bits(&s->gb, 1); /* profil and level esc*/
1406 s->avctx->profile= get_bits(&s->gb, 3);
1407 s->avctx->level= get_bits(&s->gb, 4);
1408 s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1409 s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1410 horiz_size_ext = get_bits(&s->gb, 2);
1411 vert_size_ext = get_bits(&s->gb, 2);
1412 s->width |= (horiz_size_ext << 12);
1413 s->height |= (vert_size_ext << 12);
1414 bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1415 s->bit_rate += (bit_rate_ext << 18) * 400;
1416 skip_bits1(&s->gb); /* marker */
1417 s->avctx->rc_buffer_size += get_bits(&s->gb, 8)*1024*16<<10;
1418
1419 s->low_delay = get_bits1(&s->gb);
1420 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
1421
1422 s1->frame_rate_ext.num = get_bits(&s->gb, 2)+1;
1423 s1->frame_rate_ext.den = get_bits(&s->gb, 5)+1;
1424
1425 dprintf(s->avctx, "sequence extension\n");
1426 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
1427 s->avctx->sub_id = 2; /* indicates mpeg2 found */
1428
1429 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1430 av_log(s->avctx, AV_LOG_DEBUG, "profile: %d, level: %d vbv buffer: %d, bitrate:%d\n",
1431 s->avctx->profile, s->avctx->level, s->avctx->rc_buffer_size, s->bit_rate);
1432
1433 }
1434
1435 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1436 {
1437 MpegEncContext *s= &s1->mpeg_enc_ctx;
1438 int color_description, w, h;
1439
1440 skip_bits(&s->gb, 3); /* video format */
1441 color_description= get_bits1(&s->gb);
1442 if(color_description){
1443 skip_bits(&s->gb, 8); /* color primaries */
1444 skip_bits(&s->gb, 8); /* transfer_characteristics */
1445 skip_bits(&s->gb, 8); /* matrix_coefficients */
1446 }
1447 w= get_bits(&s->gb, 14);
1448 skip_bits(&s->gb, 1); //marker
1449 h= get_bits(&s->gb, 14);
1450 skip_bits(&s->gb, 1); //marker
1451
1452 s1->pan_scan.width= 16*w;
1453 s1->pan_scan.height=16*h;
1454
1455 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1456 av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1457 }
1458
1459 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1460 {
1461 MpegEncContext *s= &s1->mpeg_enc_ctx;
1462 int i,nofco;
1463
1464 nofco = 1;
1465 if(s->progressive_sequence){
1466 if(s->repeat_first_field){
1467 nofco++;
1468 if(s->top_field_first)
1469 nofco++;
1470 }
1471 }else{
1472 if(s->picture_structure == PICT_FRAME){
1473 nofco++;
1474 if(s->repeat_first_field)
1475 nofco++;
1476 }
1477 }
1478 for(i=0; i<nofco; i++){
1479 s1->pan_scan.position[i][0]= get_sbits(&s->gb, 16);
1480 skip_bits(&s->gb, 1); //marker
1481 s1->pan_scan.position[i][1]= get_sbits(&s->gb, 16);
1482 skip_bits(&s->gb, 1); //marker
1483 }
1484
1485 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1486 av_log(s->avctx, AV_LOG_DEBUG, "pde (%d,%d) (%d,%d) (%d,%d)\n",
1487 s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1488 s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1489 s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]
1490 );
1491 }
1492
1493 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1494 {
1495 int i, v, j;
1496
1497 dprintf(s->avctx, "matrix extension\n");
1498
1499 if (get_bits1(&s->gb)) {
1500 for(i=0;i<64;i++) {
1501 v = get_bits(&s->gb, 8);
1502 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1503 s->intra_matrix[j] = v;
1504 s->chroma_intra_matrix[j] = v;
1505 }
1506 }
1507 if (get_bits1(&s->gb)) {
1508 for(i=0;i<64;i++) {
1509 v = get_bits(&s->gb, 8);
1510 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1511 s->inter_matrix[j] = v;
1512 s->chroma_inter_matrix[j] = v;
1513 }
1514 }
1515 if (get_bits1(&s->gb)) {
1516 for(i=0;i<64;i++) {
1517 v = get_bits(&s->gb, 8);
1518 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1519 s->chroma_intra_matrix[j] = v;
1520 }
1521 }
1522 if (get_bits1(&s->gb)) {
1523 for(i=0;i<64;i++) {
1524 v = get_bits(&s->gb, 8);
1525 j= s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
1526 s->chroma_inter_matrix[j] = v;
1527 }
1528 }
1529 }
1530
1531 static void mpeg_decode_picture_coding_extension(MpegEncContext *s)
1532 {
1533 s->full_pel[0] = s->full_pel[1] = 0;
1534 s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1535 s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1536 s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1537 s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1538 s->intra_dc_precision = get_bits(&s->gb, 2);
1539 s->picture_structure = get_bits(&s->gb, 2);
1540 s->top_field_first = get_bits1(&s->gb);
1541 s->frame_pred_frame_dct = get_bits1(&s->gb);
1542 s->concealment_motion_vectors = get_bits1(&s->gb);
1543 s->q_scale_type = get_bits1(&s->gb);
1544 s->intra_vlc_format = get_bits1(&s->gb);
1545 s->alternate_scan = get_bits1(&s->gb);
1546 s->repeat_first_field = get_bits1(&s->gb);
1547 s->chroma_420_type = get_bits1(&s->gb);
1548 s->progressive_frame = get_bits1(&s->gb);
1549
1550 if(s->picture_structure == PICT_FRAME){
1551 s->first_field=0;
1552 s->v_edge_pos= 16*s->mb_height;
1553 }else{
1554 s->first_field ^= 1;
1555 s->v_edge_pos= 8*s->mb_height;
1556 memset(s->mbskip_table, 0, s->mb_stride*s->mb_height);
1557 }
1558
1559 if(s->alternate_scan){
1560 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
1561 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
1562 }else{
1563 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
1564 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
1565 }
1566
1567 /* composite display not parsed */
1568 dprintf(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1569 dprintf(s->avctx, "picture_structure=%d\n", s->picture_structure);
1570 dprintf(s->avctx, "top field first=%d\n", s->top_field_first);
1571 dprintf(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1572 dprintf(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1573 dprintf(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1574 dprintf(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1575 dprintf(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1576 dprintf(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1577 }
1578
1579 static void mpeg_decode_extension(AVCodecContext *avctx,
1580 const uint8_t *buf, int buf_size)
1581 {
1582 Mpeg1Context *s1 = avctx->priv_data;
1583 MpegEncContext *s = &s1->mpeg_enc_ctx;
1584 int ext_type;
1585
1586 init_get_bits(&s->gb, buf, buf_size*8);
1587
1588 ext_type = get_bits(&s->gb, 4);
1589 switch(ext_type) {
1590 case 0x1:
1591 mpeg_decode_sequence_extension(s1);
1592 break;
1593 case 0x2:
1594 mpeg_decode_sequence_display_extension(s1);
1595 break;
1596 case 0x3:
1597 mpeg_decode_quant_matrix_extension(s);
1598 break;
1599 case 0x7:
1600 mpeg_decode_picture_display_extension(s1);
1601 break;
1602 case 0x8:
1603 mpeg_decode_picture_coding_extension(s);
1604 break;
1605 }
1606 }
1607
1608 static void exchange_uv(MpegEncContext *s){
1609 short * tmp = s->pblocks[4];
1610 s->pblocks[4] = s->pblocks[5];
1611 s->pblocks[5] = tmp;
1612 }
1613
1614 static int mpeg_field_start(MpegEncContext *s){
1615 AVCodecContext *avctx= s->avctx;
1616 Mpeg1Context *s1 = (Mpeg1Context*)s;
1617
1618 /* start frame decoding */
1619 if(s->first_field || s->picture_structure==PICT_FRAME){
1620 if(MPV_frame_start(s, avctx) < 0)
1621 return -1;
1622
1623 ff_er_frame_start(s);
1624
1625 /* first check if we must repeat the frame */
1626 s->current_picture_ptr->repeat_pict = 0;
1627 if (s->repeat_first_field) {
1628 if (s->progressive_sequence) {
1629 if (s->top_field_first)
1630 s->current_picture_ptr->repeat_pict = 4;
1631 else
1632 s->current_picture_ptr->repeat_pict = 2;
1633 } else if (s->progressive_frame) {
1634 s->current_picture_ptr->repeat_pict = 1;
1635 }
1636 }
1637
1638 *s->current_picture_ptr->pan_scan= s1->pan_scan;
1639 }else{ //second field
1640 int i;
1641
1642 if(!s->current_picture_ptr){
1643 av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1644 return -1;
1645 }
1646
1647 for(i=0; i<4; i++){
1648 s->current_picture.data[i] = s->current_picture_ptr->data[i];
1649 if(s->picture_structure == PICT_BOTTOM_FIELD){
1650 s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
1651 }
1652 }
1653 }
1654 #ifdef HAVE_XVMC
1655 // MPV_frame_start will call this function too,
1656 // but we need to call it on every field
1657 if(s->avctx->xvmc_acceleration)
1658 XVMC_field_start(s,avctx);
1659 #endif
1660
1661 return 0;
1662 }
1663
1664 #define DECODE_SLICE_ERROR -1
1665 #define DECODE_SLICE_OK 0
1666
1667 /**
1668 * decodes a slice. MpegEncContext.mb_y must be set to the MB row from the startcode
1669 * @return DECODE_SLICE_ERROR if the slice is damaged<br>
1670 * DECODE_SLICE_OK if this slice is ok<br>
1671 */
1672 static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
1673 const uint8_t **buf, int buf_size)
1674 {
1675 MpegEncContext *s = &s1->mpeg_enc_ctx;
1676 AVCodecContext *avctx= s->avctx;
1677 const int field_pic= s->picture_structure != PICT_FRAME;
1678 const int lowres= s->avctx->lowres;
1679
1680 s->resync_mb_x=
1681 s->resync_mb_y= -1;
1682
1683 if (mb_y<<field_pic >= s->mb_height){
1684 av_log(s->avctx, AV_LOG_ERROR, "slice below image (%d >= %d)\n", mb_y, s->mb_height);
1685 return -1;
1686 }
1687
1688 init_get_bits(&s->gb, *buf, buf_size*8);
1689
1690 ff_mpeg1_clean_buffers(s);
1691 s->interlaced_dct = 0;
1692
1693 s->qscale = get_qscale(s);
1694
1695 if(s->qscale == 0){
1696 av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1697 return -1;
1698 }
1699
1700 /* extra slice info */
1701 while (get_bits1(&s->gb) != 0) {
1702 skip_bits(&s->gb, 8);
1703 }
1704
1705 s->mb_x=0;
1706
1707 for(;;) {
1708 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1709 if (code < 0){
1710 av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1711 return -1;
1712 }
1713 if (code >= 33) {
1714 if (code == 33) {
1715 s->mb_x += 33;
1716 }
1717 /* otherwise, stuffing, nothing to do */
1718 } else {
1719 s->mb_x += code;
1720 break;
1721 }
1722 }
1723 if(s->mb_x >= (unsigned)s->mb_width){
1724 av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1725 return -1;
1726 }
1727
1728 s->resync_mb_x= s->mb_x;
1729 s->resync_mb_y= s->mb_y= mb_y;
1730 s->mb_skip_run= 0;
1731 ff_init_block_index(s);
1732
1733 if (s->mb_y==0 && s->mb_x==0 && (s->first_field || s->picture_structure==PICT_FRAME)) {
1734 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
1735 av_log(s->avctx, AV_LOG_DEBUG, "qp:%d fc:%2d%2d%2d%2d %s %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1736 s->qscale, s->mpeg_f_code[0][0],s->mpeg_f_code[0][1],s->mpeg_f_code[1][0],s->mpeg_f_code[1][1],
1737 s->pict_type == FF_I_TYPE ? "I" : (s->pict_type == FF_P_TYPE ? "P" : (s->pict_type == FF_B_TYPE ? "B" : "S")),
1738 s->progressive_sequence ? "ps" :"", s->progressive_frame ? "pf" : "", s->alternate_scan ? "alt" :"", s->top_field_first ? "top" :"",
1739 s->intra_dc_precision, s->picture_structure, s->frame_pred_frame_dct, s->concealment_motion_vectors,
1740 s->q_scale_type, s->intra_vlc_format, s->repeat_first_field, s->chroma_420_type ? "420" :"");
1741 }
1742 }
1743
1744 for(;;) {
1745 #ifdef HAVE_XVMC
1746 //one 1 we memcpy blocks in xvmcvideo
1747 if(s->avctx->xvmc_acceleration > 1)
1748 XVMC_init_block(s);//set s->block
1749 #endif
1750
1751 if(mpeg_decode_mb(s, s->block) < 0)
1752 return -1;
1753
1754 if(s->current_picture.motion_val[0] && !s->encoding){ //note motion_val is normally NULL unless we want to extract the MVs
1755 const int wrap = field_pic ? 2*s->b8_stride : s->b8_stride;
1756 int xy = s->mb_x*2 + s->mb_y*2*wrap;
1757 int motion_x, motion_y, dir, i;
1758 if(field_pic && !s->first_field)
1759 xy += wrap/2;
1760
1761 for(i=0; i<2; i++){
1762 for(dir=0; dir<2; dir++){
1763 if (s->mb_intra || (dir==1 && s->pict_type != FF_B_TYPE)) {
1764 motion_x = motion_y = 0;
1765 }else if (s->mv_type == MV_TYPE_16X16 || (s->mv_type == MV_TYPE_FIELD && field_pic)){
1766 motion_x = s->mv[dir][0][0];
1767 motion_y = s->mv[dir][0][1];
1768 } else /*if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8))*/ {
1769 motion_x = s->mv[dir][i][0];
1770 motion_y = s->mv[dir][i][1];
1771 }
1772
1773 s->current_picture.motion_val[dir][xy ][0] = motion_x;
1774 s->current_picture.motion_val[dir][xy ][1] = motion_y;
1775 s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1776 s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1777 s->current_picture.ref_index [dir][xy ]=
1778 s->current_picture.ref_index [dir][xy + 1]= s->field_select[dir][i];
1779 assert(s->field_select[dir][i]==0 || s->field_select[dir][i]==1);
1780 }
1781 xy += wrap;
1782 }
1783 }
1784
1785 s->dest[0] += 16 >> lowres;
1786 s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1787 s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1788
1789 MPV_decode_mb(s, s->block);
1790
1791 if (++s->mb_x >= s->mb_width) {
1792 const int mb_size= 16>>s->avctx->lowres;
1793
1794 ff_draw_horiz_band(s, mb_size*s->mb_y, mb_size);
1795
1796 s->mb_x = 0;
1797 s->mb_y++;
1798
1799 if(s->mb_y<<field_pic >= s->mb_height){
1800 int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1801 int is_d10= s->chroma_format==2 && s->pict_type==FF_I_TYPE && avctx->profile==0 && avctx->level==5
1802 && s->intra_dc_precision == 2 && s->q_scale_type == 1 && s->alternate_scan == 0
1803 && s->progressive_frame == 0 /* vbv_delay == 0xBBB || 0xE10*/;
1804
1805 if(left < 0 || (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10)
1806 || (avctx->error_resilience >= FF_ER_AGGRESSIVE && left>8)){
1807 av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n", left, show_bits(&s->gb, FFMIN(left, 23)));
1808 return -1;
1809 }else
1810 goto eos;
1811 }
1812
1813 ff_init_block_index(s);
1814 }
1815
1816 /* skip mb handling */
1817 if (s->mb_skip_run == -1) {
1818 /* read again increment */
1819 s->mb_skip_run = 0;
1820 for(;;) {
1821 int code = get_vlc2(&s->gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);
1822 if (code < 0){
1823 av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1824 return -1;
1825 }
1826 if (code >= 33) {
1827 if (code == 33) {
1828 s->mb_skip_run += 33;
1829 }else if(code == 35){
1830 if(s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0){
1831 av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1832 return -1;
1833 }
1834 goto eos; /* end of slice */
1835 }
1836 /* otherwise, stuffing, nothing to do */
1837 } else {
1838 s->mb_skip_run += code;
1839 break;
1840 }
1841 }
1842 if(s->mb_skip_run){
1843 int i;
1844 if(s->pict_type == FF_I_TYPE){
1845 av_log(s->avctx, AV_LOG_ERROR, "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1846 return -1;
1847 }
1848
1849 /* skip mb */
1850 s->mb_intra = 0;
1851 for(i=0;i<12;i++)
1852 s->block_last_index[i] = -1;
1853 if(s->picture_structure == PICT_FRAME)
1854 s->mv_type = MV_TYPE_16X16;
1855 else
1856 s->mv_type = MV_TYPE_FIELD;
1857 if (s->pict_type == FF_P_TYPE) {
1858 /* if P type, zero motion vector is implied */
1859 s->mv_dir = MV_DIR_FORWARD;
1860 s->mv[0][0][0] = s->mv[0][0][1] = 0;
1861 s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1862 s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1863 s->field_select[0][0]= s->picture_structure - 1;
1864 } else {
1865 /* if B type, reuse previous vectors and directions */
1866 s->mv[0][0][0] = s->last_mv[0][0][0];
1867 s->mv[0][0][1] = s->last_mv[0][0][1];
1868 s->mv[1][0][0] = s->last_mv[1][0][0];
1869 s->mv[1][0][1] = s->last_mv[1][0][1];
1870 }
1871 }
1872 }
1873 }
1874 eos: // end of slice
1875 *buf += (get_bits_count(&s->gb)-1)/8;
1876 //printf("y %d %d %d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1877 return 0;
1878 }
1879
1880 static int slice_decode_thread(AVCodecContext *c, void *arg){
1881 MpegEncContext *s= arg;
1882 const uint8_t *buf= s->gb.buffer;
1883 int mb_y= s->start_mb_y;
1884
1885 s->error_count= 3*(s->end_mb_y - s->start_mb_y)*s->mb_width;
1886
1887 for(;;){
1888 uint32_t start_code;
1889 int ret;
1890
1891 ret= mpeg_decode_slice((Mpeg1Context*)s, mb_y, &buf, s->gb.buffer_end - buf);
1892 emms_c();
1893 //av_log(c, AV_LOG_DEBUG, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1894 //ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, s->start_mb_y, s->end_mb_y, s->error_count);
1895 if(ret < 0){
1896 if(s->resync_mb_x>=0 && s->resync_mb_y>=0)
1897 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
1898 }else{
1899 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END);
1900 }
1901
1902 if(s->mb_y == s->end_mb_y)
1903 return 0;
1904
1905 start_code= -1;
1906 buf = ff_find_start_code(buf, s->gb.buffer_end, &start_code);
1907 mb_y= start_code - SLICE_MIN_START_CODE;
1908 if(mb_y < 0 || mb_y >= s->end_mb_y)
1909 return -1;
1910 }
1911
1912 return 0; //not reached
1913 }
1914
1915 /**
1916 * handles slice ends.
1917 * @return 1 if it seems to be the last slice of
1918 */
1919 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
1920 {
1921 Mpeg1Context *s1 = avctx->priv_data;
1922 MpegEncContext *s = &s1->mpeg_enc_ctx;
1923
1924 if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
1925 return 0;
1926
1927 #ifdef HAVE_XVMC
1928 if(s->avctx->xvmc_acceleration)
1929 XVMC_field_end(s);
1930 #endif
1931 /* end of slice reached */
1932 if (/*s->mb_y<<field_pic == s->mb_height &&*/ !s->first_field) {
1933 /* end of image */
1934
1935 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_MPEG2;
1936
1937 ff_er_frame_end(s);
1938
1939 MPV_frame_end(s);
1940
1941 if (s->pict_type == FF_B_TYPE || s->low_delay) {
1942 *pict= *(AVFrame*)s->current_picture_ptr;
1943 ff_print_debug_info(s, pict);
1944 } else {
1945 s->picture_number++;
1946 /* latency of 1 frame for I and P frames */
1947 /* XXX: use another variable than picture_number */
1948 if (s->last_picture_ptr != NULL) {
1949 *pict= *(AVFrame*)s->last_picture_ptr;
1950 ff_print_debug_info(s, pict);
1951 }
1952 }
1953
1954 return 1;
1955 } else {
1956 return 0;
1957 }
1958 }
1959
1960 static int mpeg1_decode_sequence(AVCodecContext *avctx,
1961 const uint8_t *buf, int buf_size)
1962 {
1963 Mpeg1Context *s1 = avctx->priv_data;
1964 MpegEncContext *s = &s1->mpeg_enc_ctx;
1965 int width,height;
1966 int i, v, j;
1967
1968 init_get_bits(&s->gb, buf, buf_size*8);
1969
1970 width = get_bits(&s->gb, 12);
1971 height = get_bits(&s->gb, 12);
1972 if (width <= 0 || height <= 0)
1973 return -1;
1974 s->aspect_ratio_info= get_bits(&s->gb, 4);
1975 if (s->aspect_ratio_info == 0) {
1976 av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
1977 if (avctx->error_resilience >= FF_ER_COMPLIANT)
1978 return -1;
1979 }
1980 s->frame_rate_index = get_bits(&s->gb, 4);
1981 if (s->frame_rate_index == 0 || s->frame_rate_index > 13)
1982 return -1;
1983 s->bit_rate = get_bits(&s->gb, 18) * 400;
1984 if (get_bits1(&s->gb) == 0) /* marker */
1985 return -1;
1986 s->width = width;
1987 s->height = height;
1988
1989 s->avctx->rc_buffer_size= get_bits(&s->gb, 10) * 1024*16;
1990 skip_bits(&s->gb, 1);
1991
1992 /* get matrix */
1993 if (get_bits1(&s->gb)) {
1994 for(i=0;i<64;i++) {
1995 v = get_bits(&s->gb, 8);
1996 if(v==0){
1997 av_log(s->avctx, AV_LOG_ERROR, "intra matrix damaged\n");
1998 return -1;
1999 }
2000 j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2001 s->intra_matrix[j] = v;
2002 s->chroma_intra_matrix[j] = v;
2003 }
2004 #ifdef DEBUG
2005 dprintf(s->avctx, "intra matrix present\n");
2006 for(i=0;i<64;i++)
2007 dprintf(s->avctx, " %d", s->intra_matrix[s->dsp.idct_permutation[i]]);
2008 dprintf(s->avctx, "\n");
2009 #endif
2010 } else {
2011 for(i=0;i<64;i++) {
2012 j = s->dsp.idct_permutation[i];
2013 v = ff_mpeg1_default_intra_matrix[i];
2014 s->intra_matrix[j] = v;
2015 s->chroma_intra_matrix[j] = v;
2016 }
2017 }
2018 if (get_bits1(&s->gb)) {
2019 for(i=0;i<64;i++) {
2020 v = get_bits(&s->gb, 8);
2021 if(v==0){
2022 av_log(s->avctx, AV_LOG_ERROR, "inter matrix damaged\n");
2023 return -1;
2024 }
2025 j = s->dsp.idct_permutation[ ff_zigzag_direct[i] ];
2026 s->inter_matrix[j] = v;
2027 s->chroma_inter_matrix[j] = v;
2028 }
2029 #ifdef DEBUG
2030 dprintf(s->avctx, "non intra matrix present\n");
2031 for(i=0;i<64;i++)
2032 dprintf(s->avctx, " %d", s->inter_matrix[s->dsp.idct_permutation[i]]);
2033 dprintf(s->avctx, "\n");
2034 #endif
2035 } else {
2036 for(i=0;i<64;i++) {
2037 int j= s->dsp.idct_permutation[i];
2038 v = ff_mpeg1_default_non_intra_matrix[i];
2039 s->inter_matrix[j] = v;
2040 s->chroma_inter_matrix[j] = v;
2041 }
2042 }
2043
2044 if(show_bits(&s->gb, 23) != 0){
2045 av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2046 return -1;
2047 }
2048
2049 /* we set mpeg2 parameters so that it emulates mpeg1 */
2050 s->progressive_sequence = 1;
2051 s->progressive_frame = 1;
2052 s->picture_structure = PICT_FRAME;
2053 s->frame_pred_frame_dct = 1;
2054 s->chroma_format = 1;
2055 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG1VIDEO;
2056 avctx->sub_id = 1; /* indicates mpeg1 */
2057 s->out_format = FMT_MPEG1;
2058 s->swap_uv = 0;//AFAIK VCR2 don't have SEQ_HEADER
2059 if(s->flags & CODEC_FLAG_LOW_DELAY) s->low_delay=1;
2060
2061 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2062 av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d\n",
2063 s->avctx->rc_buffer_size, s->bit_rate);
2064
2065 return 0;
2066 }
2067
2068 static int vcr2_init_sequence(AVCodecContext *avctx)
2069 {
2070 Mpeg1Context *s1 = avctx->priv_data;
2071 MpegEncContext *s = &s1->mpeg_enc_ctx;
2072 int i, v;
2073
2074 /* start new mpeg1 context decoding */
2075 s->out_format = FMT_MPEG1;
2076 if (s1->mpeg_enc_ctx_allocated) {
2077 MPV_common_end(s);
2078 }
2079 s->width = avctx->coded_width;
2080 s->height = avctx->coded_height;
2081 avctx->has_b_frames= 0; //true?
2082 s->low_delay= 1;
2083
2084 if(avctx->xvmc_acceleration){
2085 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2086 }else{
2087 avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
2088 }
2089
2090 if( avctx->pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )
2091 if( avctx->idct_algo == FF_IDCT_AUTO )
2092 avctx->idct_algo = FF_IDCT_SIMPLE;
2093
2094 if (MPV_common_init(s) < 0)
2095 return -1;
2096 exchange_uv(s);//common init reset pblocks, so we swap them here
2097 s->swap_uv = 1;// in case of xvmc we need to swap uv for each MB
2098 s1->mpeg_enc_ctx_allocated = 1;
2099
2100 for(i=0;i<64;i++) {
2101 int j= s->dsp.idct_permutation[i];
2102 v = ff_mpeg1_default_intra_matrix[i];
2103 s->intra_matrix[j] = v;
2104 s->chroma_intra_matrix[j] = v;
2105
2106 v = ff_mpeg1_default_non_intra_matrix[i];
2107 s->inter_matrix[j] = v;
2108 s->chroma_inter_matrix[j] = v;
2109 }
2110
2111 s->progressive_sequence = 1;
2112 s->progressive_frame = 1;
2113 s->picture_structure = PICT_FRAME;
2114 s->frame_pred_frame_dct = 1;
2115 s->chroma_format = 1;
2116 s->codec_id= s->avctx->codec_id= CODEC_ID_MPEG2VIDEO;
2117 avctx->sub_id = 2; /* indicates mpeg2 */
2118 return 0;
2119 }
2120
2121
2122 static void mpeg_decode_user_data(AVCodecContext *avctx,
2123 const uint8_t *buf, int buf_size)
2124 {
2125 const uint8_t *p;
2126 int len, flags;
2127 p = buf;
2128 len = buf_size;
2129
2130 /* we parse the DTG active format information */
2131 if (len >= 5 &&
2132 p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2133 flags = p[4];
2134 p += 5;
2135 len -= 5;
2136 if (flags & 0x80) {
2137 /* skip event id */
2138 if (len < 2)
2139 return;
2140 p += 2;
2141 len -= 2;
2142 }
2143 if (flags & 0x40) {
2144 if (len < 1)
2145 return;
2146 avctx->dtg_active_format = p[0] & 0x0f;
2147 }
2148 }
2149 }
2150
2151 static void mpeg_decode_gop(AVCodecContext *avctx,
2152 const uint8_t *buf, int buf_size){
2153 Mpeg1Context *s1 = avctx->priv_data;
2154 MpegEncContext *s = &s1->mpeg_enc_ctx;
2155
2156 int drop_frame_flag;
2157 int time_code_hours, time_code_minutes;
2158 int time_code_seconds, time_code_pictures;
2159 int closed_gop, broken_link;
2160
2161 init_get_bits(&s->gb, buf, buf_size*8);
2162
2163 drop_frame_flag = get_bits1(&s->gb);
2164
2165 time_code_hours=get_bits(&s->gb,5);
2166 time_code_minutes = get_bits(&s->gb,6);
2167 skip_bits1(&s->gb);//marker bit
2168 time_code_seconds = get_bits(&s->gb,6);
2169 time_code_pictures = get_bits(&s->gb,6);
2170
2171 closed_gop = get_bits1(&s->gb);
2172 /*broken_link indicate that after editing the
2173 reference frames of the first B-Frames after GOP I-Frame
2174 are missing (open gop)*/
2175 broken_link = get_bits1(&s->gb);
2176
2177 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
2178 av_log(s->avctx, AV_LOG_DEBUG, "GOP (%2d:%02d:%02d.[%02d]) closed_gop=%d broken_link=%d\n",
2179 time_code_hours, time_code_minutes, time_code_seconds,
2180 time_code_pictures, closed_gop, broken_link);
2181 }
2182 /**
2183 * finds the end of the current frame in the bitstream.
2184 * @return the position of the first byte of the next frame, or -1
2185 */
2186 int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
2187 {
2188 int i;
2189 uint32_t state= pc->state;
2190
2191 /* EOF considered as end of frame */
2192 if (buf_size == 0)
2193 return 0;
2194
2195 /*
2196 0 frame start -> 1/4
2197 1 first_SEQEXT -> 0/2
2198 2 first field start -> 3/0
2199 3 second_SEQEXT -> 2/0
2200 4 searching end
2201 */
2202
2203 for(i=0; i<buf_size; i++){
2204 assert(pc->frame_start_found>=0 && pc->frame_start_found<=4);
2205 if(pc->frame_start_found&1){
2206 if(state == EXT_START_CODE && (buf[i]&0xF0) != 0x80)
2207 pc->frame_start_found--;
2208 else if(state == EXT_START_CODE+2){
2209 if((buf[i]&3) == 3) pc->frame_start_found= 0;
2210 else pc->frame_start_found= (pc->frame_start_found+1)&3;
2211 }
2212 state++;
2213 }else{
2214 i= ff_find_start_code(buf+i, buf+buf_size, &state) - buf - 1;
2215 if(pc->frame_start_found==0 && state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){
2216 i++;
2217 pc->frame_start_found=4;
2218 }
2219 if(state == SEQ_END_CODE){
2220 pc->state=-1;
2221 return i+1;
2222 }
2223 if(pc->frame_start_found==2 && state == SEQ_START_CODE)
2224 pc->frame_start_found= 0;
2225 if(pc->frame_start_found<4 && state == EXT_START_CODE)
2226 pc->frame_start_found++;
2227 if(pc->frame_start_found == 4 && (state&0xFFFFFF00) == 0x100){
2228 if(state < SLICE_MIN_START_CODE || state > SLICE_MAX_START_CODE){
2229 pc->frame_start_found=0;
2230 pc->state=-1;
2231 return i-3;
2232 }
2233 }
2234 }
2235 }
2236 pc->state= state;
2237 return END_NOT_FOUND;
2238 }
2239
2240 static int decode_chunks(AVCodecContext *avctx,
2241 AVFrame *picture, int *data_size,
2242 const uint8_t *buf, int buf_size);
2243
2244 /* handle buffering and image synchronisation */
2245 static int mpeg_decode_frame(AVCodecContext *avctx,
2246 void *data, int *data_size,
2247 const uint8_t *buf, int buf_size)
2248 {
2249 Mpeg1Context *s = avctx->priv_data;
2250 AVFrame *picture = data;
2251 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2252 dprintf(avctx, "fill_buffer\n");
2253
2254 if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2255 /* special case for last picture */
2256 if (s2->low_delay==0 && s2->next_picture_ptr) {
2257 *picture= *(AVFrame*)s2->next_picture_ptr;
2258 s2->next_picture_ptr= NULL;
2259
2260 *data_size = sizeof(AVFrame);
2261 }
2262 return buf_size;
2263 }
2264
2265 if(s2->flags&CODEC_FLAG_TRUNCATED){
2266 int next= ff_mpeg1_find_frame_end(&s2->parse_context, buf, buf_size);
2267
2268 if( ff_combine_frame(&s2->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
2269 return buf_size;
2270 }
2271
2272 #if 0
2273 if (s->repeat_field % 2 == 1) {
2274 s->repeat_field++;
2275 //fprintf(stderr,"\nRepeating last frame: %d -> %d! pict: %d %d", avctx->frame_number-1, avctx->frame_number,
2276 // s2->picture_number, s->repeat_field);
2277 if (avctx->flags & CODEC_FLAG_REPEAT_FIELD) {
2278 *data_size = sizeof(AVPicture);
2279 goto the_end;
2280 }
2281 }
2282 #endif
2283
2284 if(s->mpeg_enc_ctx_allocated==0 && avctx->codec_tag == ff_get_fourcc("VCR2"))
2285 vcr2_init_sequence(avctx);
2286
2287 s->slice_count= 0;
2288
2289 if(avctx->extradata && !avctx->frame_number)
2290 decode_chunks(avctx, picture, data_size, avctx->extradata, avctx->extradata_size);
2291
2292 return decode_chunks(avctx, picture, data_size, buf, buf_size);
2293 }
2294
2295 static int decode_chunks(AVCodecContext *avctx,
2296 AVFrame *picture, int *data_size,
2297 const uint8_t *buf, int buf_size)
2298 {
2299 Mpeg1Context *s = avctx->priv_data;
2300 MpegEncContext *s2 = &s->mpeg_enc_ctx;
2301 const uint8_t *buf_ptr = buf;
2302 const uint8_t *buf_end = buf + buf_size;
2303 int ret, input_size;
2304
2305 for(;;) {
2306 /* find start next code */
2307 uint32_t start_code = -1;
2308 buf_ptr = ff_find_start_code(buf_ptr,buf_end, &start_code);
2309 if (start_code > 0x1ff){
2310 if(s2->pict_type != FF_B_TYPE || avctx->skip_frame <= AVDISCARD_DEFAULT){
2311 if(avctx->thread_count > 1){
2312 int i;
2313
2314 avctx->execute(avctx, slice_decode_thread, (void**)&(s2->thread_context[0]), NULL, s->slice_count);
2315 for(i=0; i<s->slice_count; i++)
2316 s2->error_count += s2->thread_context[i]->error_count;
2317 }
2318 if (slice_end(avctx, picture)) {
2319 if(s2->last_picture_ptr || s2->low_delay) //FIXME merge with the stuff in mpeg_decode_slice
2320 *data_size = sizeof(AVPicture);
2321 }
2322 }
2323 return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2324 }
2325
2326 input_size = buf_end - buf_ptr;
2327
2328 if(avctx->debug & FF_DEBUG_STARTCODE){
2329 av_log(avctx, AV_LOG_DEBUG, "%3X at %td left %d\n", start_code, buf_ptr-buf, input_size);
2330 }
2331
2332 /* prepare data for next start code */
2333 switch(start_code) {
2334 case SEQ_START_CODE:
2335 mpeg1_decode_sequence(avctx, buf_ptr,
2336 input_size);
2337 break;
2338
2339 case PICTURE_START_CODE:
2340 /* we have a complete image : we try to decompress it */
2341 mpeg1_decode_picture(avctx,
2342 buf_ptr, input_size);
2343 break;
2344 case EXT_START_CODE:
2345 mpeg_decode_extension(avctx,
2346 buf_ptr, input_size);
2347 break;
2348 case USER_START_CODE:
2349 mpeg_decode_user_data(avctx,
2350 buf_ptr, input_size);
2351 break;
2352 case GOP_START_CODE:
2353 s2->first_field=0;
2354 mpeg_decode_gop(avctx,
2355 buf_ptr, input_size);
2356 break;
2357 default:
2358 if (start_code >= SLICE_MIN_START_CODE &&
2359 start_code <= SLICE_MAX_START_CODE) {
2360 int mb_y= start_code - SLICE_MIN_START_CODE;
2361
2362 if(s2->last_picture_ptr==NULL){
2363 /* Skip B-frames if we do not have reference frames. */
2364 if(s2->pict_type==FF_B_TYPE) break;
2365 }
2366 if(s2->next_picture_ptr==NULL){
2367 /* Skip P-frames if we do not have reference frame no valid header. */
2368 if(s2->pict_type==FF_P_TYPE && (s2->first_field || s2->picture_structure==PICT_FRAME)) break;
2369 }
2370 /* Skip B-frames if we are in a hurry. */
2371 if(avctx->hurry_up && s2->pict_type==FF_B_TYPE) break;
2372 if( (avctx->skip_frame >= AVDISCARD_NONREF && s2->pict_type==FF_B_TYPE)
2373 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s2->pict_type!=FF_I_TYPE)
2374 || avctx->skip_frame >= AVDISCARD_ALL)
2375 break;
2376 /* Skip everything if we are in a hurry>=5. */
2377 if(avctx->hurry_up>=5) break;
2378
2379 if (!s->mpeg_enc_ctx_allocated) break;
2380
2381 if(s2->codec_id == CODEC_ID_MPEG2VIDEO){
2382 if(mb_y < avctx->skip_top || mb_y >= s2->mb_height - avctx->skip_bottom)
2383 break;
2384 }
2385
2386 if(s2->first_slice){
2387 s2->first_slice=0;
2388 if(mpeg_field_start(s2) < 0)
2389 return -1;
2390 }
2391 if(!s2->current_picture_ptr){
2392 av_log(avctx, AV_LOG_ERROR, "current_picture not initialized\n");
2393 return -1;
2394 }
2395
2396 if(avctx->thread_count > 1){
2397 int threshold= (s2->mb_height*s->slice_count + avctx->thread_count/2) / avctx->thread_count;
2398 if(threshold <= mb_y){
2399 MpegEncContext *thread_context= s2->thread_context[s->slice_count];
2400
2401 thread_context->start_mb_y= mb_y;
2402 thread_context->end_mb_y = s2->mb_height;
2403 if(s->slice_count){
2404 s2->thread_context[s->slice_count-1]->end_mb_y= mb_y;
2405 ff_update_duplicate_context(thread_context, s2);
2406 }
2407 init_get_bits(&thread_context->gb, buf_ptr, input_size*8);
2408 s->slice_count++;
2409 }
2410 buf_ptr += 2; //FIXME add minimum num of bytes per slice
2411 }else{
2412 ret = mpeg_decode_slice(s, mb_y, &buf_ptr, input_size);
2413 emms_c();
2414
2415 if(ret < 0){
2416 if(s2->resync_mb_x>=0 && s2->resync_mb_y>=0)
2417 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x, s2->mb_y, AC_ERROR|DC_ERROR|MV_ERROR);
2418 }else{
2419 ff_er_add_slice(s2, s2->resync_mb_x, s2->resync_mb_y, s2->mb_x-1, s2->mb_y, AC_END|DC_END|MV_END);
2420 }
2421 }
2422 }
2423 break;
2424 }
2425 }
2426 }
2427
2428 static int mpeg_decode_end(AVCodecContext *avctx)
2429 {
2430 Mpeg1Context *s = avctx->priv_data;
2431
2432 if (s->mpeg_enc_ctx_allocated)
2433 MPV_common_end(&s->mpeg_enc_ctx);
2434 return 0;
2435 }
2436
2437 AVCodec mpeg1video_decoder = {
2438 "mpeg1video",
2439 CODEC_TYPE_VIDEO,
2440 CODEC_ID_MPEG1VIDEO,
2441 sizeof(Mpeg1Context),
2442 mpeg_decode_init,
2443 NULL,
2444 mpeg_decode_end,
2445 mpeg_decode_frame,
2446 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2447 .flush= ff_mpeg_flush,
2448 .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2449 };
2450
2451 AVCodec mpeg2video_decoder = {
2452 "mpeg2video",
2453 CODEC_TYPE_VIDEO,
2454 CODEC_ID_MPEG2VIDEO,
2455 sizeof(Mpeg1Context),
2456 mpeg_decode_init,
2457 NULL,
2458 mpeg_decode_end,
2459 mpeg_decode_frame,
2460 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2461 .flush= ff_mpeg_flush,
2462 .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2463 };
2464
2465 //legacy decoder
2466 AVCodec mpegvideo_decoder = {
2467 "mpegvideo",
2468 CODEC_TYPE_VIDEO,
2469 CODEC_ID_MPEG2VIDEO,
2470 sizeof(Mpeg1Context),
2471 mpeg_decode_init,
2472 NULL,
2473 mpeg_decode_end,
2474 mpeg_decode_frame,
2475 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
2476 .flush= ff_mpeg_flush,
2477 .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2478 };
2479
2480 #ifdef HAVE_XVMC
2481 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx){
2482 Mpeg1Context *s;
2483
2484 if( avctx->thread_count > 1)
2485 return -1;
2486 if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
2487 return -1;
2488 if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ){
2489 dprintf(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2490 }
2491 mpeg_decode_init(avctx);
2492 s = avctx->priv_data;
2493
2494 avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT;
2495 avctx->xvmc_acceleration = 2;//2 - the blocks are packed!
2496
2497 return 0;
2498 }
2499
2500 AVCodec mpeg_xvmc_decoder = {
2501 "mpegvideo_xvmc",
2502 CODEC_TYPE_VIDEO,
2503 CODEC_ID_MPEG2VIDEO_XVMC,
2504 sizeof(Mpeg1Context),
2505 mpeg_mc_decode_init,
2506 NULL,
2507 mpeg_decode_end,
2508 mpeg_decode_frame,
2509 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2510 .flush= ff_mpeg_flush,
2511 .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video XvMC (X-Video Motion Compensation)"),
2512 };
2513
2514 #endif
2515
2516 /* this is ugly i know, but the alternative is too make
2517 hundreds of vars global and prefix them with ff_mpeg1_
2518 which is far uglier. */
2519 #include "mdec.c"
An experimental fork of FFmpeg project for DVCPRO-HD developers