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