Mercurial > libavcodec.hg
annotate mpeg12enc.c @ 12454:f4355cd85faa libavcodec
Port latest x264 deblock asm (before they moved to using NV12 as internal
format), LGPL'ed with permission from Jason and Loren. This includes mmx2
code, so remove inline asm from h264dsp_mmx.c accordingly.
author | rbultje |
---|---|
date | Fri, 03 Sep 2010 16:52:46 +0000 |
parents | b6cf19580e47 |
children |
rev | line source |
---|---|
5208 | 1 /* |
2 * MPEG1/2 encoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
7260
diff
changeset
|
3 * Copyright (c) 2000,2001 Fabrice Bellard |
5208 | 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 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
24 * @file |
5208 | 25 * MPEG1/2 encoder |
26 */ | |
27 | |
28 #include "avcodec.h" | |
29 #include "dsputil.h" | |
30 #include "mpegvideo.h" | |
31 | |
32 #include "mpeg12.h" | |
33 #include "mpeg12data.h" | |
34 #include "bytestream.h" | |
35 | |
36 | |
37 static const uint8_t inv_non_linear_qscale[13] = { | |
38 0, 2, 4, 6, 8, | |
39 9,10,11,12,13,14,15,16, | |
40 }; | |
41 | |
42 static const uint8_t svcd_scan_offset_placeholder[14] = { | |
43 0x10, 0x0E, | |
44 0x00, 0x80, 0x81, | |
45 0x00, 0x80, 0x81, | |
46 0xff, 0xff, 0xff, | |
47 0xff, 0xff, 0xff, | |
48 }; | |
49 | |
50 static void mpeg1_encode_block(MpegEncContext *s, | |
51 DCTELEM *block, | |
52 int component); | |
53 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added | |
54 | |
55 static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; | |
56 static uint8_t fcode_tab[MAX_MV*2+1]; | |
57 | |
58 static uint8_t uni_mpeg1_ac_vlc_len [64*64*2]; | |
59 static uint8_t uni_mpeg2_ac_vlc_len [64*64*2]; | |
60 | |
61 /* simple include everything table for dc, first byte is bits number next 3 are code*/ | |
62 static uint32_t mpeg1_lum_dc_uni[512]; | |
63 static uint32_t mpeg1_chr_dc_uni[512]; | |
64 | |
65 static uint8_t mpeg1_index_run[2][64]; | |
66 static int8_t mpeg1_max_level[2][64]; | |
67 | |
68 static void init_uni_ac_vlc(RLTable *rl, uint8_t *uni_ac_vlc_len){ | |
69 int i; | |
70 | |
71 for(i=0; i<128; i++){ | |
72 int level= i-64; | |
73 int run; | |
74 for(run=0; run<64; run++){ | |
75 int len, bits, code; | |
76 | |
77 int alevel= FFABS(level); | |
78 int sign= (level>>31)&1; | |
79 | |
80 if (alevel > rl->max_level[0][run]) | |
81 code= 111; /*rl->n*/ | |
82 else | |
83 code= rl->index_run[0][run] + alevel - 1; | |
84 | |
85 if (code < 111 /* rl->n */) { | |
86 /* store the vlc & sign at once */ | |
87 len= rl->table_vlc[code][1]+1; | |
88 bits= (rl->table_vlc[code][0]<<1) + sign; | |
89 } else { | |
90 len= rl->table_vlc[111/*rl->n*/][1]+6; | |
91 bits= rl->table_vlc[111/*rl->n*/][0]<<6; | |
92 | |
93 bits|= run; | |
94 if (alevel < 128) { | |
95 bits<<=8; len+=8; | |
96 bits|= level & 0xff; | |
97 } else { | |
98 bits<<=16; len+=16; | |
99 bits|= level & 0xff; | |
100 if (level < 0) { | |
101 bits|= 0x8001 + level + 255; | |
102 } else { | |
103 bits|= level & 0xffff; | |
104 } | |
105 } | |
106 } | |
107 | |
108 uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len; | |
109 } | |
110 } | |
111 } | |
112 | |
113 | |
114 static int find_frame_rate_index(MpegEncContext *s){ | |
115 int i; | |
116 int64_t dmin= INT64_MAX; | |
117 int64_t d; | |
118 | |
119 for(i=1;i<14;i++) { | |
120 int64_t n0= 1001LL/ff_frame_rate_tab[i].den*ff_frame_rate_tab[i].num*s->avctx->time_base.num; | |
121 int64_t n1= 1001LL*s->avctx->time_base.den; | |
12084
b6cf19580e47
Change all occurences of "inofficial" to "unofficial" in code, comments
cehoyos
parents:
11644
diff
changeset
|
122 if(s->avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL && i>=9) break; |
5208 | 123 |
124 d = FFABS(n0 - n1); | |
125 if(d < dmin){ | |
126 dmin=d; | |
127 s->frame_rate_index= i; | |
128 } | |
129 } | |
130 if(dmin) | |
131 return -1; | |
132 else | |
133 return 0; | |
134 } | |
135 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
136 static av_cold int encode_init(AVCodecContext *avctx) |
5208 | 137 { |
138 MpegEncContext *s = avctx->priv_data; | |
139 | |
140 if(MPV_encode_init(avctx) < 0) | |
141 return -1; | |
142 | |
143 if(find_frame_rate_index(s) < 0){ | |
144 if(s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){ | |
145 av_log(avctx, AV_LOG_ERROR, "MPEG1/2 does not support %d/%d fps\n", avctx->time_base.den, avctx->time_base.num); | |
146 return -1; | |
147 }else{ | |
148 av_log(avctx, AV_LOG_INFO, "MPEG1/2 does not support %d/%d fps, there may be AV sync issues\n", avctx->time_base.den, avctx->time_base.num); | |
149 } | |
150 } | |
151 | |
152 if(avctx->profile == FF_PROFILE_UNKNOWN){ | |
153 if(avctx->level != FF_LEVEL_UNKNOWN){ | |
154 av_log(avctx, AV_LOG_ERROR, "Set profile and level\n"); | |
155 return -1; | |
156 } | |
157 avctx->profile = s->chroma_format == CHROMA_420 ? 4 : 0; /* Main or 4:2:2 */ | |
158 } | |
159 | |
160 if(avctx->level == FF_LEVEL_UNKNOWN){ | |
161 if(avctx->profile == 0){ /* 4:2:2 */ | |
162 if(avctx->width <= 720 && avctx->height <= 608) avctx->level = 5; /* Main */ | |
163 else avctx->level = 2; /* High */ | |
164 }else{ | |
165 if(avctx->profile != 1 && s->chroma_format != CHROMA_420){ | |
166 av_log(avctx, AV_LOG_ERROR, "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n"); | |
167 return -1; | |
168 } | |
169 if(avctx->width <= 720 && avctx->height <= 576) avctx->level = 8; /* Main */ | |
170 else if(avctx->width <= 1440) avctx->level = 6; /* High 1440 */ | |
171 else avctx->level = 4; /* High */ | |
172 } | |
173 } | |
174 | |
175 if((avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) && s->frame_rate_index != 4){ | |
176 av_log(avctx, AV_LOG_ERROR, "Drop frame time code only allowed with 1001/30000 fps\n"); | |
177 return -1; | |
178 } | |
179 | |
180 return 0; | |
181 } | |
182 | |
183 static void put_header(MpegEncContext *s, int header) | |
184 { | |
185 align_put_bits(&s->pb); | |
186 put_bits(&s->pb, 16, header>>16); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
187 put_sbits(&s->pb, 16, header); |
5208 | 188 } |
189 | |
190 /* put sequence header if needed */ | |
191 static void mpeg1_encode_sequence_header(MpegEncContext *s) | |
192 { | |
193 unsigned int vbv_buffer_size; | |
194 unsigned int fps, v; | |
195 int i; | |
196 uint64_t time_code; | |
197 float best_aspect_error= 1E10; | |
198 float aspect_ratio= av_q2d(s->avctx->sample_aspect_ratio); | |
199 int constraint_parameter_flag; | |
200 | |
201 if(aspect_ratio==0.0) aspect_ratio= 1.0; //pixel aspect 1:1 (VGA) | |
202 | |
203 if (s->current_picture.key_frame) { | |
204 AVRational framerate= ff_frame_rate_tab[s->frame_rate_index]; | |
205 | |
206 /* mpeg1 header repeated every gop */ | |
207 put_header(s, SEQ_START_CODE); | |
208 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
209 put_sbits(&s->pb, 12, s->width ); |
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
210 put_sbits(&s->pb, 12, s->height); |
5208 | 211 |
212 for(i=1; i<15; i++){ | |
213 float error= aspect_ratio; | |
214 if(s->codec_id == CODEC_ID_MPEG1VIDEO || i <=1) | |
5210 | 215 error-= 1.0/ff_mpeg1_aspect[i]; |
5208 | 216 else |
5210 | 217 error-= av_q2d(ff_mpeg2_aspect[i])*s->height/s->width; |
5208 | 218 |
219 error= FFABS(error); | |
220 | |
221 if(error < best_aspect_error){ | |
222 best_aspect_error= error; | |
223 s->aspect_ratio_info= i; | |
224 } | |
225 } | |
226 | |
227 put_bits(&s->pb, 4, s->aspect_ratio_info); | |
228 put_bits(&s->pb, 4, s->frame_rate_index); | |
229 | |
230 if(s->avctx->rc_max_rate){ | |
231 v = (s->avctx->rc_max_rate + 399) / 400; | |
232 if (v > 0x3ffff && s->codec_id == CODEC_ID_MPEG1VIDEO) | |
233 v = 0x3ffff; | |
234 }else{ | |
235 v= 0x3FFFF; | |
236 } | |
237 | |
238 if(s->avctx->rc_buffer_size) | |
239 vbv_buffer_size = s->avctx->rc_buffer_size; | |
240 else | |
241 /* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */ | |
242 vbv_buffer_size = (( 20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024; | |
243 vbv_buffer_size= (vbv_buffer_size + 16383) / 16384; | |
244 | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
245 put_sbits(&s->pb, 18, v); |
5208 | 246 put_bits(&s->pb, 1, 1); /* marker */ |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
247 put_sbits(&s->pb, 10, vbv_buffer_size); |
5208 | 248 |
249 constraint_parameter_flag= | |
250 s->width <= 768 && s->height <= 576 && | |
251 s->mb_width * s->mb_height <= 396 && | |
252 s->mb_width * s->mb_height * framerate.num <= framerate.den*396*25 && | |
253 framerate.num <= framerate.den*30 && | |
254 s->avctx->me_range && s->avctx->me_range < 128 && | |
255 vbv_buffer_size <= 20 && | |
256 v <= 1856000/400 && | |
257 s->codec_id == CODEC_ID_MPEG1VIDEO; | |
258 | |
259 put_bits(&s->pb, 1, constraint_parameter_flag); | |
260 | |
261 ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); | |
262 ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); | |
263 | |
264 if(s->codec_id == CODEC_ID_MPEG2VIDEO){ | |
265 put_header(s, EXT_START_CODE); | |
266 put_bits(&s->pb, 4, 1); //seq ext | |
267 | |
268 put_bits(&s->pb, 1, s->avctx->profile == 0); //escx 1 for 4:2:2 profile */ | |
269 | |
270 put_bits(&s->pb, 3, s->avctx->profile); //profile | |
271 put_bits(&s->pb, 4, s->avctx->level); //level | |
272 | |
273 put_bits(&s->pb, 1, s->progressive_sequence); | |
274 put_bits(&s->pb, 2, s->chroma_format); | |
7143 | 275 put_bits(&s->pb, 2, s->width >>12); |
276 put_bits(&s->pb, 2, s->height>>12); | |
5208 | 277 put_bits(&s->pb, 12, v>>18); //bitrate ext |
278 put_bits(&s->pb, 1, 1); //marker | |
279 put_bits(&s->pb, 8, vbv_buffer_size >>10); //vbv buffer ext | |
280 put_bits(&s->pb, 1, s->low_delay); | |
281 put_bits(&s->pb, 2, 0); // frame_rate_ext_n | |
282 put_bits(&s->pb, 5, 0); // frame_rate_ext_d | |
283 } | |
284 | |
285 put_header(s, GOP_START_CODE); | |
286 put_bits(&s->pb, 1, !!(s->avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE)); /* drop frame flag */ | |
287 /* time code : we must convert from the real frame rate to a | |
288 fake mpeg frame rate in case of low frame rate */ | |
289 fps = (framerate.num + framerate.den/2)/ framerate.den; | |
290 time_code = s->current_picture_ptr->coded_picture_number + s->avctx->timecode_frame_start; | |
291 | |
292 s->gop_picture_number = s->current_picture_ptr->coded_picture_number; | |
293 if (s->avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) { | |
294 /* only works for NTSC 29.97 */ | |
295 int d = time_code / 17982; | |
296 int m = time_code % 17982; | |
297 //if (m < 2) m += 2; /* not needed since -2,-1 / 1798 in C returns 0 */ | |
298 time_code += 18 * d + 2 * ((m - 2) / 1798); | |
299 } | |
300 put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24)); | |
301 put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60)); | |
302 put_bits(&s->pb, 1, 1); | |
303 put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60)); | |
304 put_bits(&s->pb, 6, (uint32_t)((time_code % fps))); | |
305 put_bits(&s->pb, 1, !!(s->flags & CODEC_FLAG_CLOSED_GOP)); | |
306 put_bits(&s->pb, 1, 0); /* broken link */ | |
307 } | |
308 } | |
309 | |
310 static inline void encode_mb_skip_run(MpegEncContext *s, int run){ | |
311 while (run >= 33) { | |
312 put_bits(&s->pb, 11, 0x008); | |
313 run -= 33; | |
314 } | |
5210 | 315 put_bits(&s->pb, ff_mpeg12_mbAddrIncrTable[run][1], |
316 ff_mpeg12_mbAddrIncrTable[run][0]); | |
5208 | 317 } |
318 | |
319 static av_always_inline void put_qscale(MpegEncContext *s) | |
320 { | |
321 if(s->q_scale_type){ | |
322 assert(s->qscale>=1 && s->qscale <=12); | |
323 put_bits(&s->pb, 5, inv_non_linear_qscale[s->qscale]); | |
324 }else{ | |
325 put_bits(&s->pb, 5, s->qscale); | |
326 } | |
327 } | |
328 | |
329 void ff_mpeg1_encode_slice_header(MpegEncContext *s){ | |
10195 | 330 if (s->height > 2800) { |
331 put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127)); | |
332 put_bits(&s->pb, 3, s->mb_y >> 7); /* slice_vertical_position_extension */ | |
333 } else { | |
10196 | 334 put_header(s, SLICE_MIN_START_CODE + s->mb_y); |
10195 | 335 } |
5208 | 336 put_qscale(s); |
337 put_bits(&s->pb, 1, 0); /* slice extra information */ | |
338 } | |
339 | |
340 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) | |
341 { | |
342 mpeg1_encode_sequence_header(s); | |
343 | |
344 /* mpeg1 picture header */ | |
345 put_header(s, PICTURE_START_CODE); | |
346 /* temporal reference */ | |
347 | |
348 // RAL: s->picture_number instead of s->fake_picture_number | |
349 put_bits(&s->pb, 10, (s->picture_number - | |
350 s->gop_picture_number) & 0x3ff); | |
351 put_bits(&s->pb, 3, s->pict_type); | |
352 | |
353 s->vbv_delay_ptr= s->pb.buf + put_bits_count(&s->pb)/8; | |
354 put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */ | |
355 | |
356 // RAL: Forward f_code also needed for B frames | |
6481 | 357 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) { |
5208 | 358 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
359 if(s->codec_id == CODEC_ID_MPEG1VIDEO) | |
360 put_bits(&s->pb, 3, s->f_code); /* forward_f_code */ | |
361 else | |
362 put_bits(&s->pb, 3, 7); /* forward_f_code */ | |
363 } | |
364 | |
365 // RAL: Backward f_code necessary for B frames | |
6481 | 366 if (s->pict_type == FF_B_TYPE) { |
5208 | 367 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
368 if(s->codec_id == CODEC_ID_MPEG1VIDEO) | |
369 put_bits(&s->pb, 3, s->b_code); /* backward_f_code */ | |
370 else | |
371 put_bits(&s->pb, 3, 7); /* backward_f_code */ | |
372 } | |
373 | |
374 put_bits(&s->pb, 1, 0); /* extra bit picture */ | |
375 | |
376 s->frame_pred_frame_dct = 1; | |
377 if(s->codec_id == CODEC_ID_MPEG2VIDEO){ | |
378 put_header(s, EXT_START_CODE); | |
379 put_bits(&s->pb, 4, 8); //pic ext | |
6481 | 380 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) { |
5208 | 381 put_bits(&s->pb, 4, s->f_code); |
382 put_bits(&s->pb, 4, s->f_code); | |
383 }else{ | |
384 put_bits(&s->pb, 8, 255); | |
385 } | |
6481 | 386 if (s->pict_type == FF_B_TYPE) { |
5208 | 387 put_bits(&s->pb, 4, s->b_code); |
388 put_bits(&s->pb, 4, s->b_code); | |
389 }else{ | |
390 put_bits(&s->pb, 8, 255); | |
391 } | |
392 put_bits(&s->pb, 2, s->intra_dc_precision); | |
393 | |
394 assert(s->picture_structure == PICT_FRAME); | |
395 put_bits(&s->pb, 2, s->picture_structure); | |
396 if (s->progressive_sequence) { | |
397 put_bits(&s->pb, 1, 0); /* no repeat */ | |
398 } else { | |
399 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); | |
400 } | |
401 /* XXX: optimize the generation of this flag with entropy | |
402 measures */ | |
403 s->frame_pred_frame_dct = s->progressive_sequence; | |
404 | |
405 put_bits(&s->pb, 1, s->frame_pred_frame_dct); | |
406 put_bits(&s->pb, 1, s->concealment_motion_vectors); | |
407 put_bits(&s->pb, 1, s->q_scale_type); | |
408 put_bits(&s->pb, 1, s->intra_vlc_format); | |
409 put_bits(&s->pb, 1, s->alternate_scan); | |
410 put_bits(&s->pb, 1, s->repeat_first_field); | |
411 s->progressive_frame = s->progressive_sequence; | |
412 put_bits(&s->pb, 1, s->chroma_format == CHROMA_420 ? s->progressive_frame : 0); /* chroma_420_type */ | |
413 put_bits(&s->pb, 1, s->progressive_frame); | |
414 put_bits(&s->pb, 1, 0); //composite_display_flag | |
415 } | |
416 if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){ | |
417 int i; | |
418 | |
419 put_header(s, USER_START_CODE); | |
420 for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){ | |
421 put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]); | |
422 } | |
423 } | |
424 | |
425 s->mb_y=0; | |
426 ff_mpeg1_encode_slice_header(s); | |
427 } | |
428 | |
429 static inline void put_mb_modes(MpegEncContext *s, int n, int bits, | |
430 int has_mv, int field_motion) | |
431 { | |
432 put_bits(&s->pb, n, bits); | |
433 if (!s->frame_pred_frame_dct) { | |
434 if (has_mv) | |
435 put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */ | |
436 put_bits(&s->pb, 1, s->interlaced_dct); | |
437 } | |
438 } | |
439 | |
440 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, | |
441 DCTELEM block[6][64], | |
442 int motion_x, int motion_y, | |
443 int mb_block_count) | |
444 { | |
445 int i, cbp; | |
446 const int mb_x = s->mb_x; | |
447 const int mb_y = s->mb_y; | |
448 const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y; | |
449 | |
450 /* compute cbp */ | |
451 cbp = 0; | |
452 for(i=0;i<mb_block_count;i++) { | |
453 if (s->block_last_index[i] >= 0) | |
454 cbp |= 1 << (mb_block_count - 1 - i); | |
455 } | |
456 | |
457 if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 && | |
458 (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) && | |
6481 | 459 ((s->pict_type == FF_P_TYPE && (motion_x | motion_y) == 0) || |
460 (s->pict_type == FF_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) | | |
5208 | 461 ((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))) { |
462 s->mb_skip_run++; | |
463 s->qscale -= s->dquant; | |
464 s->skip_count++; | |
465 s->misc_bits++; | |
466 s->last_bits++; | |
6481 | 467 if(s->pict_type == FF_P_TYPE){ |
5208 | 468 s->last_mv[0][1][0]= s->last_mv[0][0][0]= |
469 s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0; | |
470 } | |
471 } else { | |
472 if(first_mb){ | |
473 assert(s->mb_skip_run == 0); | |
474 encode_mb_skip_run(s, s->mb_x); | |
475 }else{ | |
476 encode_mb_skip_run(s, s->mb_skip_run); | |
477 } | |
478 | |
6481 | 479 if (s->pict_type == FF_I_TYPE) { |
5208 | 480 if(s->dquant && cbp){ |
481 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */ | |
482 put_qscale(s); | |
483 }else{ | |
484 put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */ | |
485 s->qscale -= s->dquant; | |
486 } | |
487 s->misc_bits+= get_bits_diff(s); | |
488 s->i_count++; | |
489 } else if (s->mb_intra) { | |
490 if(s->dquant && cbp){ | |
491 put_mb_modes(s, 6, 0x01, 0, 0); | |
492 put_qscale(s); | |
493 }else{ | |
494 put_mb_modes(s, 5, 0x03, 0, 0); | |
495 s->qscale -= s->dquant; | |
496 } | |
497 s->misc_bits+= get_bits_diff(s); | |
498 s->i_count++; | |
499 memset(s->last_mv, 0, sizeof(s->last_mv)); | |
6481 | 500 } else if (s->pict_type == FF_P_TYPE) { |
5208 | 501 if(s->mv_type == MV_TYPE_16X16){ |
502 if (cbp != 0) { | |
503 if ((motion_x|motion_y) == 0) { | |
504 if(s->dquant){ | |
505 put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */ | |
506 put_qscale(s); | |
507 }else{ | |
508 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */ | |
509 } | |
510 s->misc_bits+= get_bits_diff(s); | |
511 } else { | |
512 if(s->dquant){ | |
513 put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */ | |
514 put_qscale(s); | |
515 }else{ | |
516 put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */ | |
517 } | |
518 s->misc_bits+= get_bits_diff(s); | |
519 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added | |
520 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added | |
521 s->mv_bits+= get_bits_diff(s); | |
522 } | |
523 } else { | |
524 put_bits(&s->pb, 3, 1); /* motion only */ | |
525 if (!s->frame_pred_frame_dct) | |
526 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
527 s->misc_bits+= get_bits_diff(s); | |
528 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added | |
529 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added | |
530 s->qscale -= s->dquant; | |
531 s->mv_bits+= get_bits_diff(s); | |
532 } | |
533 s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x; | |
534 s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y; | |
535 }else{ | |
536 assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD); | |
537 | |
538 if (cbp) { | |
539 if(s->dquant){ | |
540 put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */ | |
541 put_qscale(s); | |
542 }else{ | |
543 put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */ | |
544 } | |
545 } else { | |
546 put_bits(&s->pb, 3, 1); /* motion only */ | |
547 put_bits(&s->pb, 2, 1); /* motion_type: field */ | |
548 s->qscale -= s->dquant; | |
549 } | |
550 s->misc_bits+= get_bits_diff(s); | |
551 for(i=0; i<2; i++){ | |
552 put_bits(&s->pb, 1, s->field_select[0][i]); | |
553 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
554 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
555 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
556 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
557 } | |
558 s->mv_bits+= get_bits_diff(s); | |
559 } | |
560 if(cbp) { | |
561 if (s->chroma_y_shift) { | |
5210 | 562 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
5208 | 563 } else { |
5210 | 564 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp>>2][1], ff_mpeg12_mbPatTable[cbp>>2][0]); |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
565 put_sbits(&s->pb, 2, cbp); |
5208 | 566 } |
567 } | |
568 s->f_count++; | |
569 } else{ | |
570 if(s->mv_type == MV_TYPE_16X16){ | |
571 if (cbp){ // With coded bloc pattern | |
572 if (s->dquant) { | |
573 if(s->mv_dir == MV_DIR_FORWARD) | |
574 put_mb_modes(s, 6, 3, 1, 0); | |
575 else | |
5446 | 576 put_mb_modes(s, 8-s->mv_dir, 2, 1, 0); |
5208 | 577 put_qscale(s); |
578 } else { | |
5446 | 579 put_mb_modes(s, 5-s->mv_dir, 3, 1, 0); |
5208 | 580 } |
581 }else{ // No coded bloc pattern | |
5446 | 582 put_bits(&s->pb, 5-s->mv_dir, 2); |
5208 | 583 if (!s->frame_pred_frame_dct) |
584 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
585 s->qscale -= s->dquant; | |
586 } | |
587 s->misc_bits += get_bits_diff(s); | |
588 if (s->mv_dir&MV_DIR_FORWARD){ | |
589 mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
590 mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
591 s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0]; | |
592 s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1]; | |
593 s->f_count++; | |
594 } | |
595 if (s->mv_dir&MV_DIR_BACKWARD){ | |
596 mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
597 mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
598 s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0]; | |
599 s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1]; | |
600 s->b_count++; | |
601 } | |
602 }else{ | |
603 assert(s->mv_type == MV_TYPE_FIELD); | |
604 assert(!s->frame_pred_frame_dct); | |
605 if (cbp){ // With coded bloc pattern | |
606 if (s->dquant) { | |
607 if(s->mv_dir == MV_DIR_FORWARD) | |
608 put_mb_modes(s, 6, 3, 1, 1); | |
609 else | |
5446 | 610 put_mb_modes(s, 8-s->mv_dir, 2, 1, 1); |
5208 | 611 put_qscale(s); |
612 } else { | |
5446 | 613 put_mb_modes(s, 5-s->mv_dir, 3, 1, 1); |
5208 | 614 } |
615 }else{ // No coded bloc pattern | |
5446 | 616 put_bits(&s->pb, 5-s->mv_dir, 2); |
5208 | 617 put_bits(&s->pb, 2, 1); /* motion_type: field */ |
618 s->qscale -= s->dquant; | |
619 } | |
620 s->misc_bits += get_bits_diff(s); | |
621 if (s->mv_dir&MV_DIR_FORWARD){ | |
622 for(i=0; i<2; i++){ | |
623 put_bits(&s->pb, 1, s->field_select[0][i]); | |
624 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
625 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
626 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
627 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
628 } | |
629 s->f_count++; | |
630 } | |
631 if (s->mv_dir&MV_DIR_BACKWARD){ | |
632 for(i=0; i<2; i++){ | |
633 put_bits(&s->pb, 1, s->field_select[1][i]); | |
634 mpeg1_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code); | |
635 mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code); | |
636 s->last_mv[1][i][0]= s->mv[1][i][0]; | |
637 s->last_mv[1][i][1]= 2*s->mv[1][i][1]; | |
638 } | |
639 s->b_count++; | |
640 } | |
641 } | |
642 s->mv_bits += get_bits_diff(s); | |
643 if(cbp) { | |
644 if (s->chroma_y_shift) { | |
5210 | 645 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
5208 | 646 } else { |
5210 | 647 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp>>2][1], ff_mpeg12_mbPatTable[cbp>>2][0]); |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
648 put_sbits(&s->pb, 2, cbp); |
5208 | 649 } |
650 } | |
651 } | |
652 for(i=0;i<mb_block_count;i++) { | |
653 if (cbp & (1 << (mb_block_count - 1 - i))) { | |
654 mpeg1_encode_block(s, block[i], i); | |
655 } | |
656 } | |
657 s->mb_skip_run = 0; | |
658 if(s->mb_intra) | |
659 s->i_tex_bits+= get_bits_diff(s); | |
660 else | |
661 s->p_tex_bits+= get_bits_diff(s); | |
662 } | |
663 } | |
664 | |
665 void mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y) | |
666 { | |
667 if (s->chroma_format == CHROMA_420) mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6); | |
668 else mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8); | |
669 } | |
670 | |
671 // RAL: Parameter added: f_or_b_code | |
672 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) | |
673 { | |
674 if (val == 0) { | |
675 /* zero vector */ | |
676 put_bits(&s->pb, | |
5210 | 677 ff_mpeg12_mbMotionVectorTable[0][1], |
678 ff_mpeg12_mbMotionVectorTable[0][0]); | |
5208 | 679 } else { |
9457
6fe0b0ff991a
Move declarations in mpeg1_encode_motion() closer to where they are needed.
michael
parents:
9456
diff
changeset
|
680 int code, sign, bits; |
6fe0b0ff991a
Move declarations in mpeg1_encode_motion() closer to where they are needed.
michael
parents:
9456
diff
changeset
|
681 int bit_size = f_or_b_code - 1; |
6fe0b0ff991a
Move declarations in mpeg1_encode_motion() closer to where they are needed.
michael
parents:
9456
diff
changeset
|
682 int range = 1 << bit_size; |
5208 | 683 /* modulo encoding */ |
9457
6fe0b0ff991a
Move declarations in mpeg1_encode_motion() closer to where they are needed.
michael
parents:
9456
diff
changeset
|
684 int l= INT_BIT - 5 - bit_size; |
5208 | 685 val= (val<<l)>>l; |
686 | |
687 if (val >= 0) { | |
688 val--; | |
689 code = (val >> bit_size) + 1; | |
690 bits = val & (range - 1); | |
691 sign = 0; | |
692 } else { | |
693 val = -val; | |
694 val--; | |
695 code = (val >> bit_size) + 1; | |
696 bits = val & (range - 1); | |
697 sign = 1; | |
698 } | |
699 | |
700 assert(code > 0 && code <= 16); | |
701 | |
702 put_bits(&s->pb, | |
5210 | 703 ff_mpeg12_mbMotionVectorTable[code][1], |
704 ff_mpeg12_mbMotionVectorTable[code][0]); | |
5208 | 705 |
706 put_bits(&s->pb, 1, sign); | |
707 if (bit_size > 0) { | |
708 put_bits(&s->pb, bit_size, bits); | |
709 } | |
710 } | |
711 } | |
712 | |
713 void ff_mpeg1_encode_init(MpegEncContext *s) | |
714 { | |
715 static int done=0; | |
716 | |
5210 | 717 ff_mpeg12_common_init(s); |
5208 | 718 |
719 if(!done){ | |
720 int f_code; | |
721 int mv; | |
722 int i; | |
723 | |
724 done=1; | |
5210 | 725 init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]); |
726 init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]); | |
5208 | 727 |
728 for(i=0; i<64; i++) | |
729 { | |
5210 | 730 mpeg1_max_level[0][i]= ff_rl_mpeg1.max_level[0][i]; |
731 mpeg1_index_run[0][i]= ff_rl_mpeg1.index_run[0][i]; | |
5208 | 732 } |
733 | |
5210 | 734 init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len); |
5208 | 735 if(s->intra_vlc_format) |
5210 | 736 init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len); |
5208 | 737 |
738 /* build unified dc encoding tables */ | |
739 for(i=-255; i<256; i++) | |
740 { | |
741 int adiff, index; | |
742 int bits, code; | |
743 int diff=i; | |
744 | |
745 adiff = FFABS(diff); | |
746 if(diff<0) diff--; | |
747 index = av_log2(2*adiff); | |
748 | |
5210 | 749 bits= ff_mpeg12_vlc_dc_lum_bits[index] + index; |
750 code= (ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1)); | |
5208 | 751 mpeg1_lum_dc_uni[i+255]= bits + (code<<8); |
752 | |
5210 | 753 bits= ff_mpeg12_vlc_dc_chroma_bits[index] + index; |
754 code= (ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1)); | |
5208 | 755 mpeg1_chr_dc_uni[i+255]= bits + (code<<8); |
756 } | |
757 | |
758 for(f_code=1; f_code<=MAX_FCODE; f_code++){ | |
759 for(mv=-MAX_MV; mv<=MAX_MV; mv++){ | |
760 int len; | |
761 | |
5210 | 762 if(mv==0) len= ff_mpeg12_mbMotionVectorTable[0][1]; |
5208 | 763 else{ |
764 int val, bit_size, range, code; | |
765 | |
766 bit_size = f_code - 1; | |
767 range = 1 << bit_size; | |
768 | |
769 val=mv; | |
770 if (val < 0) | |
771 val = -val; | |
772 val--; | |
773 code = (val >> bit_size) + 1; | |
774 if(code<17){ | |
5210 | 775 len= ff_mpeg12_mbMotionVectorTable[code][1] + 1 + bit_size; |
5208 | 776 }else{ |
5210 | 777 len= ff_mpeg12_mbMotionVectorTable[16][1] + 2 + bit_size; |
5208 | 778 } |
779 } | |
780 | |
781 mv_penalty[f_code][mv+MAX_MV]= len; | |
782 } | |
783 } | |
784 | |
785 | |
786 for(f_code=MAX_FCODE; f_code>0; f_code--){ | |
787 for(mv=-(8<<f_code); mv<(8<<f_code); mv++){ | |
788 fcode_tab[mv+MAX_MV]= f_code; | |
789 } | |
790 } | |
791 } | |
792 s->me.mv_penalty= mv_penalty; | |
793 s->fcode_tab= fcode_tab; | |
794 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ | |
795 s->min_qcoeff=-255; | |
796 s->max_qcoeff= 255; | |
797 }else{ | |
798 s->min_qcoeff=-2047; | |
799 s->max_qcoeff= 2047; | |
800 } | |
801 if (s->intra_vlc_format) { | |
802 s->intra_ac_vlc_length= | |
803 s->intra_ac_vlc_last_length= uni_mpeg2_ac_vlc_len; | |
804 } else { | |
805 s->intra_ac_vlc_length= | |
806 s->intra_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; | |
807 } | |
808 s->inter_ac_vlc_length= | |
809 s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; | |
810 } | |
811 | |
812 static inline void encode_dc(MpegEncContext *s, int diff, int component) | |
813 { | |
814 if(((unsigned) (diff+255)) >= 511){ | |
815 int index; | |
816 | |
817 if(diff<0){ | |
818 index= av_log2_16bit(-2*diff); | |
819 diff--; | |
820 }else{ | |
821 index= av_log2_16bit(2*diff); | |
822 } | |
823 if (component == 0) { | |
824 put_bits( | |
825 &s->pb, | |
5210 | 826 ff_mpeg12_vlc_dc_lum_bits[index] + index, |
827 (ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1))); | |
5208 | 828 }else{ |
829 put_bits( | |
830 &s->pb, | |
5210 | 831 ff_mpeg12_vlc_dc_chroma_bits[index] + index, |
832 (ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1))); | |
5208 | 833 } |
834 }else{ | |
835 if (component == 0) { | |
836 put_bits( | |
837 &s->pb, | |
838 mpeg1_lum_dc_uni[diff+255]&0xFF, | |
839 mpeg1_lum_dc_uni[diff+255]>>8); | |
840 } else { | |
841 put_bits( | |
842 &s->pb, | |
843 mpeg1_chr_dc_uni[diff+255]&0xFF, | |
844 mpeg1_chr_dc_uni[diff+255]>>8); | |
845 } | |
846 } | |
847 } | |
848 | |
849 static void mpeg1_encode_block(MpegEncContext *s, | |
850 DCTELEM *block, | |
851 int n) | |
852 { | |
853 int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign; | |
854 int code, component; | |
5210 | 855 const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc; |
5208 | 856 |
857 last_index = s->block_last_index[n]; | |
858 | |
859 /* DC coef */ | |
860 if (s->mb_intra) { | |
861 component = (n <= 3 ? 0 : (n&1) + 1); | |
862 dc = block[0]; /* overflow is impossible */ | |
863 diff = dc - s->last_dc[component]; | |
864 encode_dc(s, diff, component); | |
865 s->last_dc[component] = dc; | |
866 i = 1; | |
867 if (s->intra_vlc_format) | |
5210 | 868 table_vlc = ff_rl_mpeg2.table_vlc; |
5208 | 869 } else { |
870 /* encode the first coefficient : needs to be done here because | |
871 it is handled slightly differently */ | |
872 level = block[0]; | |
873 if (abs(level) == 1) { | |
874 code = ((uint32_t)level >> 31); /* the sign bit */ | |
875 put_bits(&s->pb, 2, code | 0x02); | |
876 i = 1; | |
877 } else { | |
878 i = 0; | |
879 last_non_zero = -1; | |
880 goto next_coef; | |
881 } | |
882 } | |
883 | |
884 /* now quantify & encode AC coefs */ | |
885 last_non_zero = i - 1; | |
886 | |
887 for(;i<=last_index;i++) { | |
888 j = s->intra_scantable.permutated[i]; | |
889 level = block[j]; | |
890 next_coef: | |
891 #if 0 | |
892 if (level != 0) | |
893 dprintf(s->avctx, "level[%d]=%d\n", i, level); | |
894 #endif | |
895 /* encode using VLC */ | |
896 if (level != 0) { | |
897 run = i - last_non_zero - 1; | |
898 | |
899 alevel= level; | |
900 MASK_ABS(sign, alevel) | |
901 sign&=1; | |
902 | |
903 if (alevel <= mpeg1_max_level[0][run]){ | |
904 code= mpeg1_index_run[0][run] + alevel - 1; | |
905 /* store the vlc & sign at once */ | |
906 put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign); | |
907 } else { | |
908 /* escape seems to be pretty rare <5% so I do not optimize it */ | |
909 put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]); | |
910 /* escape: only clip in this case */ | |
911 put_bits(&s->pb, 6, run); | |
912 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ | |
913 if (alevel < 128) { | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
914 put_sbits(&s->pb, 8, level); |
5208 | 915 } else { |
916 if (level < 0) { | |
917 put_bits(&s->pb, 16, 0x8001 + level + 255); | |
918 } else { | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
919 put_sbits(&s->pb, 16, level); |
5208 | 920 } |
921 } | |
922 }else{ | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
923 put_sbits(&s->pb, 12, level); |
5208 | 924 } |
925 } | |
926 last_non_zero = i; | |
927 } | |
928 } | |
929 /* end of block */ | |
930 put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]); | |
931 } | |
932 | |
933 AVCodec mpeg1video_encoder = { | |
934 "mpeg1video", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
10196
diff
changeset
|
935 AVMEDIA_TYPE_VIDEO, |
5208 | 936 CODEC_ID_MPEG1VIDEO, |
937 sizeof(MpegEncContext), | |
938 encode_init, | |
939 MPV_encode_picture, | |
940 MPV_encode_end, | |
941 .supported_framerates= ff_frame_rate_tab+1, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
9457
diff
changeset
|
942 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
5208 | 943 .capabilities= CODEC_CAP_DELAY, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6788
diff
changeset
|
944 .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"), |
5208 | 945 }; |
946 | |
947 AVCodec mpeg2video_encoder = { | |
948 "mpeg2video", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
10196
diff
changeset
|
949 AVMEDIA_TYPE_VIDEO, |
5208 | 950 CODEC_ID_MPEG2VIDEO, |
951 sizeof(MpegEncContext), | |
952 encode_init, | |
953 MPV_encode_picture, | |
954 MPV_encode_end, | |
955 .supported_framerates= ff_frame_rate_tab+1, | |
10146
38cfe222e1a4
Mark all pix_fmts and supported_framerates compound literals as const.
reimar
parents:
9457
diff
changeset
|
956 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE}, |
5208 | 957 .capabilities= CODEC_CAP_DELAY, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6788
diff
changeset
|
958 .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"), |
5208 | 959 }; |