Mercurial > libavcodec.hg
annotate mpeg12enc.c @ 9675:2e84b386a8b6 libavcodec
Fix for a problem with inverted sign of output data from ffvorbis decoder.
Now the sign of audio samples in ffvorbis output is the same as in original
uncompressed audio file and this also allows the use of tiny_psnr to compare
ffvorbis with libvorbis/tremor.
author | serge |
---|---|
date | Wed, 20 May 2009 07:24:38 +0000 |
parents | 6fe0b0ff991a |
children | 38cfe222e1a4 |
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 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8629
diff
changeset
|
24 * @file libavcodec/mpeg12enc.c |
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; | |
122 if(s->avctx->strict_std_compliance > FF_COMPLIANCE_INOFFICIAL && i>=9) break; | |
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){ | |
330 put_header(s, SLICE_MIN_START_CODE + s->mb_y); | |
331 put_qscale(s); | |
332 put_bits(&s->pb, 1, 0); /* slice extra information */ | |
333 } | |
334 | |
335 void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) | |
336 { | |
337 mpeg1_encode_sequence_header(s); | |
338 | |
339 /* mpeg1 picture header */ | |
340 put_header(s, PICTURE_START_CODE); | |
341 /* temporal reference */ | |
342 | |
343 // RAL: s->picture_number instead of s->fake_picture_number | |
344 put_bits(&s->pb, 10, (s->picture_number - | |
345 s->gop_picture_number) & 0x3ff); | |
346 put_bits(&s->pb, 3, s->pict_type); | |
347 | |
348 s->vbv_delay_ptr= s->pb.buf + put_bits_count(&s->pb)/8; | |
349 put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */ | |
350 | |
351 // RAL: Forward f_code also needed for B frames | |
6481 | 352 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) { |
5208 | 353 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
354 if(s->codec_id == CODEC_ID_MPEG1VIDEO) | |
355 put_bits(&s->pb, 3, s->f_code); /* forward_f_code */ | |
356 else | |
357 put_bits(&s->pb, 3, 7); /* forward_f_code */ | |
358 } | |
359 | |
360 // RAL: Backward f_code necessary for B frames | |
6481 | 361 if (s->pict_type == FF_B_TYPE) { |
5208 | 362 put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
363 if(s->codec_id == CODEC_ID_MPEG1VIDEO) | |
364 put_bits(&s->pb, 3, s->b_code); /* backward_f_code */ | |
365 else | |
366 put_bits(&s->pb, 3, 7); /* backward_f_code */ | |
367 } | |
368 | |
369 put_bits(&s->pb, 1, 0); /* extra bit picture */ | |
370 | |
371 s->frame_pred_frame_dct = 1; | |
372 if(s->codec_id == CODEC_ID_MPEG2VIDEO){ | |
373 put_header(s, EXT_START_CODE); | |
374 put_bits(&s->pb, 4, 8); //pic ext | |
6481 | 375 if (s->pict_type == FF_P_TYPE || s->pict_type == FF_B_TYPE) { |
5208 | 376 put_bits(&s->pb, 4, s->f_code); |
377 put_bits(&s->pb, 4, s->f_code); | |
378 }else{ | |
379 put_bits(&s->pb, 8, 255); | |
380 } | |
6481 | 381 if (s->pict_type == FF_B_TYPE) { |
5208 | 382 put_bits(&s->pb, 4, s->b_code); |
383 put_bits(&s->pb, 4, s->b_code); | |
384 }else{ | |
385 put_bits(&s->pb, 8, 255); | |
386 } | |
387 put_bits(&s->pb, 2, s->intra_dc_precision); | |
388 | |
389 assert(s->picture_structure == PICT_FRAME); | |
390 put_bits(&s->pb, 2, s->picture_structure); | |
391 if (s->progressive_sequence) { | |
392 put_bits(&s->pb, 1, 0); /* no repeat */ | |
393 } else { | |
394 put_bits(&s->pb, 1, s->current_picture_ptr->top_field_first); | |
395 } | |
396 /* XXX: optimize the generation of this flag with entropy | |
397 measures */ | |
398 s->frame_pred_frame_dct = s->progressive_sequence; | |
399 | |
400 put_bits(&s->pb, 1, s->frame_pred_frame_dct); | |
401 put_bits(&s->pb, 1, s->concealment_motion_vectors); | |
402 put_bits(&s->pb, 1, s->q_scale_type); | |
403 put_bits(&s->pb, 1, s->intra_vlc_format); | |
404 put_bits(&s->pb, 1, s->alternate_scan); | |
405 put_bits(&s->pb, 1, s->repeat_first_field); | |
406 s->progressive_frame = s->progressive_sequence; | |
407 put_bits(&s->pb, 1, s->chroma_format == CHROMA_420 ? s->progressive_frame : 0); /* chroma_420_type */ | |
408 put_bits(&s->pb, 1, s->progressive_frame); | |
409 put_bits(&s->pb, 1, 0); //composite_display_flag | |
410 } | |
411 if(s->flags & CODEC_FLAG_SVCD_SCAN_OFFSET){ | |
412 int i; | |
413 | |
414 put_header(s, USER_START_CODE); | |
415 for(i=0; i<sizeof(svcd_scan_offset_placeholder); i++){ | |
416 put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]); | |
417 } | |
418 } | |
419 | |
420 s->mb_y=0; | |
421 ff_mpeg1_encode_slice_header(s); | |
422 } | |
423 | |
424 static inline void put_mb_modes(MpegEncContext *s, int n, int bits, | |
425 int has_mv, int field_motion) | |
426 { | |
427 put_bits(&s->pb, n, bits); | |
428 if (!s->frame_pred_frame_dct) { | |
429 if (has_mv) | |
430 put_bits(&s->pb, 2, 2 - field_motion); /* motion_type: frame/field */ | |
431 put_bits(&s->pb, 1, s->interlaced_dct); | |
432 } | |
433 } | |
434 | |
435 static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, | |
436 DCTELEM block[6][64], | |
437 int motion_x, int motion_y, | |
438 int mb_block_count) | |
439 { | |
440 int i, cbp; | |
441 const int mb_x = s->mb_x; | |
442 const int mb_y = s->mb_y; | |
443 const int first_mb= mb_x == s->resync_mb_x && mb_y == s->resync_mb_y; | |
444 | |
445 /* compute cbp */ | |
446 cbp = 0; | |
447 for(i=0;i<mb_block_count;i++) { | |
448 if (s->block_last_index[i] >= 0) | |
449 cbp |= 1 << (mb_block_count - 1 - i); | |
450 } | |
451 | |
452 if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 && | |
453 (mb_x != s->mb_width - 1 || (mb_y != s->mb_height - 1 && s->codec_id == CODEC_ID_MPEG1VIDEO)) && | |
6481 | 454 ((s->pict_type == FF_P_TYPE && (motion_x | motion_y) == 0) || |
455 (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 | 456 ((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))) { |
457 s->mb_skip_run++; | |
458 s->qscale -= s->dquant; | |
459 s->skip_count++; | |
460 s->misc_bits++; | |
461 s->last_bits++; | |
6481 | 462 if(s->pict_type == FF_P_TYPE){ |
5208 | 463 s->last_mv[0][1][0]= s->last_mv[0][0][0]= |
464 s->last_mv[0][1][1]= s->last_mv[0][0][1]= 0; | |
465 } | |
466 } else { | |
467 if(first_mb){ | |
468 assert(s->mb_skip_run == 0); | |
469 encode_mb_skip_run(s, s->mb_x); | |
470 }else{ | |
471 encode_mb_skip_run(s, s->mb_skip_run); | |
472 } | |
473 | |
6481 | 474 if (s->pict_type == FF_I_TYPE) { |
5208 | 475 if(s->dquant && cbp){ |
476 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_type : macroblock_quant = 1 */ | |
477 put_qscale(s); | |
478 }else{ | |
479 put_mb_modes(s, 1, 1, 0, 0); /* macroblock_type : macroblock_quant = 0 */ | |
480 s->qscale -= s->dquant; | |
481 } | |
482 s->misc_bits+= get_bits_diff(s); | |
483 s->i_count++; | |
484 } else if (s->mb_intra) { | |
485 if(s->dquant && cbp){ | |
486 put_mb_modes(s, 6, 0x01, 0, 0); | |
487 put_qscale(s); | |
488 }else{ | |
489 put_mb_modes(s, 5, 0x03, 0, 0); | |
490 s->qscale -= s->dquant; | |
491 } | |
492 s->misc_bits+= get_bits_diff(s); | |
493 s->i_count++; | |
494 memset(s->last_mv, 0, sizeof(s->last_mv)); | |
6481 | 495 } else if (s->pict_type == FF_P_TYPE) { |
5208 | 496 if(s->mv_type == MV_TYPE_16X16){ |
497 if (cbp != 0) { | |
498 if ((motion_x|motion_y) == 0) { | |
499 if(s->dquant){ | |
500 put_mb_modes(s, 5, 1, 0, 0); /* macroblock_pattern & quant */ | |
501 put_qscale(s); | |
502 }else{ | |
503 put_mb_modes(s, 2, 1, 0, 0); /* macroblock_pattern only */ | |
504 } | |
505 s->misc_bits+= get_bits_diff(s); | |
506 } else { | |
507 if(s->dquant){ | |
508 put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */ | |
509 put_qscale(s); | |
510 }else{ | |
511 put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */ | |
512 } | |
513 s->misc_bits+= get_bits_diff(s); | |
514 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added | |
515 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added | |
516 s->mv_bits+= get_bits_diff(s); | |
517 } | |
518 } else { | |
519 put_bits(&s->pb, 3, 1); /* motion only */ | |
520 if (!s->frame_pred_frame_dct) | |
521 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
522 s->misc_bits+= get_bits_diff(s); | |
523 mpeg1_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code); // RAL: f_code parameter added | |
524 mpeg1_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code); // RAL: f_code parameter added | |
525 s->qscale -= s->dquant; | |
526 s->mv_bits+= get_bits_diff(s); | |
527 } | |
528 s->last_mv[0][1][0]= s->last_mv[0][0][0]= motion_x; | |
529 s->last_mv[0][1][1]= s->last_mv[0][0][1]= motion_y; | |
530 }else{ | |
531 assert(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD); | |
532 | |
533 if (cbp) { | |
534 if(s->dquant){ | |
535 put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */ | |
536 put_qscale(s); | |
537 }else{ | |
538 put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */ | |
539 } | |
540 } else { | |
541 put_bits(&s->pb, 3, 1); /* motion only */ | |
542 put_bits(&s->pb, 2, 1); /* motion_type: field */ | |
543 s->qscale -= s->dquant; | |
544 } | |
545 s->misc_bits+= get_bits_diff(s); | |
546 for(i=0; i<2; i++){ | |
547 put_bits(&s->pb, 1, s->field_select[0][i]); | |
548 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
549 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
550 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
551 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
552 } | |
553 s->mv_bits+= get_bits_diff(s); | |
554 } | |
555 if(cbp) { | |
556 if (s->chroma_y_shift) { | |
5210 | 557 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
5208 | 558 } else { |
5210 | 559 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
|
560 put_sbits(&s->pb, 2, cbp); |
5208 | 561 } |
562 } | |
563 s->f_count++; | |
564 } else{ | |
565 if(s->mv_type == MV_TYPE_16X16){ | |
566 if (cbp){ // With coded bloc pattern | |
567 if (s->dquant) { | |
568 if(s->mv_dir == MV_DIR_FORWARD) | |
569 put_mb_modes(s, 6, 3, 1, 0); | |
570 else | |
5446 | 571 put_mb_modes(s, 8-s->mv_dir, 2, 1, 0); |
5208 | 572 put_qscale(s); |
573 } else { | |
5446 | 574 put_mb_modes(s, 5-s->mv_dir, 3, 1, 0); |
5208 | 575 } |
576 }else{ // No coded bloc pattern | |
5446 | 577 put_bits(&s->pb, 5-s->mv_dir, 2); |
5208 | 578 if (!s->frame_pred_frame_dct) |
579 put_bits(&s->pb, 2, 2); /* motion_type: frame */ | |
580 s->qscale -= s->dquant; | |
581 } | |
582 s->misc_bits += get_bits_diff(s); | |
583 if (s->mv_dir&MV_DIR_FORWARD){ | |
584 mpeg1_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code); | |
585 mpeg1_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code); | |
586 s->last_mv[0][0][0]=s->last_mv[0][1][0]= s->mv[0][0][0]; | |
587 s->last_mv[0][0][1]=s->last_mv[0][1][1]= s->mv[0][0][1]; | |
588 s->f_count++; | |
589 } | |
590 if (s->mv_dir&MV_DIR_BACKWARD){ | |
591 mpeg1_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code); | |
592 mpeg1_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code); | |
593 s->last_mv[1][0][0]=s->last_mv[1][1][0]= s->mv[1][0][0]; | |
594 s->last_mv[1][0][1]=s->last_mv[1][1][1]= s->mv[1][0][1]; | |
595 s->b_count++; | |
596 } | |
597 }else{ | |
598 assert(s->mv_type == MV_TYPE_FIELD); | |
599 assert(!s->frame_pred_frame_dct); | |
600 if (cbp){ // With coded bloc pattern | |
601 if (s->dquant) { | |
602 if(s->mv_dir == MV_DIR_FORWARD) | |
603 put_mb_modes(s, 6, 3, 1, 1); | |
604 else | |
5446 | 605 put_mb_modes(s, 8-s->mv_dir, 2, 1, 1); |
5208 | 606 put_qscale(s); |
607 } else { | |
5446 | 608 put_mb_modes(s, 5-s->mv_dir, 3, 1, 1); |
5208 | 609 } |
610 }else{ // No coded bloc pattern | |
5446 | 611 put_bits(&s->pb, 5-s->mv_dir, 2); |
5208 | 612 put_bits(&s->pb, 2, 1); /* motion_type: field */ |
613 s->qscale -= s->dquant; | |
614 } | |
615 s->misc_bits += get_bits_diff(s); | |
616 if (s->mv_dir&MV_DIR_FORWARD){ | |
617 for(i=0; i<2; i++){ | |
618 put_bits(&s->pb, 1, s->field_select[0][i]); | |
619 mpeg1_encode_motion(s, s->mv[0][i][0] - s->last_mv[0][i][0] , s->f_code); | |
620 mpeg1_encode_motion(s, s->mv[0][i][1] - (s->last_mv[0][i][1]>>1), s->f_code); | |
621 s->last_mv[0][i][0]= s->mv[0][i][0]; | |
622 s->last_mv[0][i][1]= 2*s->mv[0][i][1]; | |
623 } | |
624 s->f_count++; | |
625 } | |
626 if (s->mv_dir&MV_DIR_BACKWARD){ | |
627 for(i=0; i<2; i++){ | |
628 put_bits(&s->pb, 1, s->field_select[1][i]); | |
629 mpeg1_encode_motion(s, s->mv[1][i][0] - s->last_mv[1][i][0] , s->b_code); | |
630 mpeg1_encode_motion(s, s->mv[1][i][1] - (s->last_mv[1][i][1]>>1), s->b_code); | |
631 s->last_mv[1][i][0]= s->mv[1][i][0]; | |
632 s->last_mv[1][i][1]= 2*s->mv[1][i][1]; | |
633 } | |
634 s->b_count++; | |
635 } | |
636 } | |
637 s->mv_bits += get_bits_diff(s); | |
638 if(cbp) { | |
639 if (s->chroma_y_shift) { | |
5210 | 640 put_bits(&s->pb, ff_mpeg12_mbPatTable[cbp][1], ff_mpeg12_mbPatTable[cbp][0]); |
5208 | 641 } else { |
5210 | 642 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
|
643 put_sbits(&s->pb, 2, cbp); |
5208 | 644 } |
645 } | |
646 } | |
647 for(i=0;i<mb_block_count;i++) { | |
648 if (cbp & (1 << (mb_block_count - 1 - i))) { | |
649 mpeg1_encode_block(s, block[i], i); | |
650 } | |
651 } | |
652 s->mb_skip_run = 0; | |
653 if(s->mb_intra) | |
654 s->i_tex_bits+= get_bits_diff(s); | |
655 else | |
656 s->p_tex_bits+= get_bits_diff(s); | |
657 } | |
658 } | |
659 | |
660 void mpeg1_encode_mb(MpegEncContext *s, DCTELEM block[6][64], int motion_x, int motion_y) | |
661 { | |
662 if (s->chroma_format == CHROMA_420) mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6); | |
663 else mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8); | |
664 } | |
665 | |
666 // RAL: Parameter added: f_or_b_code | |
667 static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) | |
668 { | |
669 if (val == 0) { | |
670 /* zero vector */ | |
671 put_bits(&s->pb, | |
5210 | 672 ff_mpeg12_mbMotionVectorTable[0][1], |
673 ff_mpeg12_mbMotionVectorTable[0][0]); | |
5208 | 674 } else { |
9457
6fe0b0ff991a
Move declarations in mpeg1_encode_motion() closer to where they are needed.
michael
parents:
9456
diff
changeset
|
675 int code, sign, bits; |
6fe0b0ff991a
Move declarations in mpeg1_encode_motion() closer to where they are needed.
michael
parents:
9456
diff
changeset
|
676 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
|
677 int range = 1 << bit_size; |
5208 | 678 /* modulo encoding */ |
9457
6fe0b0ff991a
Move declarations in mpeg1_encode_motion() closer to where they are needed.
michael
parents:
9456
diff
changeset
|
679 int l= INT_BIT - 5 - bit_size; |
5208 | 680 val= (val<<l)>>l; |
681 | |
682 if (val >= 0) { | |
683 val--; | |
684 code = (val >> bit_size) + 1; | |
685 bits = val & (range - 1); | |
686 sign = 0; | |
687 } else { | |
688 val = -val; | |
689 val--; | |
690 code = (val >> bit_size) + 1; | |
691 bits = val & (range - 1); | |
692 sign = 1; | |
693 } | |
694 | |
695 assert(code > 0 && code <= 16); | |
696 | |
697 put_bits(&s->pb, | |
5210 | 698 ff_mpeg12_mbMotionVectorTable[code][1], |
699 ff_mpeg12_mbMotionVectorTable[code][0]); | |
5208 | 700 |
701 put_bits(&s->pb, 1, sign); | |
702 if (bit_size > 0) { | |
703 put_bits(&s->pb, bit_size, bits); | |
704 } | |
705 } | |
706 } | |
707 | |
708 void ff_mpeg1_encode_init(MpegEncContext *s) | |
709 { | |
710 static int done=0; | |
711 | |
5210 | 712 ff_mpeg12_common_init(s); |
5208 | 713 |
714 if(!done){ | |
715 int f_code; | |
716 int mv; | |
717 int i; | |
718 | |
719 done=1; | |
5210 | 720 init_rl(&ff_rl_mpeg1, ff_mpeg12_static_rl_table_store[0]); |
721 init_rl(&ff_rl_mpeg2, ff_mpeg12_static_rl_table_store[1]); | |
5208 | 722 |
723 for(i=0; i<64; i++) | |
724 { | |
5210 | 725 mpeg1_max_level[0][i]= ff_rl_mpeg1.max_level[0][i]; |
726 mpeg1_index_run[0][i]= ff_rl_mpeg1.index_run[0][i]; | |
5208 | 727 } |
728 | |
5210 | 729 init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len); |
5208 | 730 if(s->intra_vlc_format) |
5210 | 731 init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len); |
5208 | 732 |
733 /* build unified dc encoding tables */ | |
734 for(i=-255; i<256; i++) | |
735 { | |
736 int adiff, index; | |
737 int bits, code; | |
738 int diff=i; | |
739 | |
740 adiff = FFABS(diff); | |
741 if(diff<0) diff--; | |
742 index = av_log2(2*adiff); | |
743 | |
5210 | 744 bits= ff_mpeg12_vlc_dc_lum_bits[index] + index; |
745 code= (ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1)); | |
5208 | 746 mpeg1_lum_dc_uni[i+255]= bits + (code<<8); |
747 | |
5210 | 748 bits= ff_mpeg12_vlc_dc_chroma_bits[index] + index; |
749 code= (ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1)); | |
5208 | 750 mpeg1_chr_dc_uni[i+255]= bits + (code<<8); |
751 } | |
752 | |
753 for(f_code=1; f_code<=MAX_FCODE; f_code++){ | |
754 for(mv=-MAX_MV; mv<=MAX_MV; mv++){ | |
755 int len; | |
756 | |
5210 | 757 if(mv==0) len= ff_mpeg12_mbMotionVectorTable[0][1]; |
5208 | 758 else{ |
759 int val, bit_size, range, code; | |
760 | |
761 bit_size = f_code - 1; | |
762 range = 1 << bit_size; | |
763 | |
764 val=mv; | |
765 if (val < 0) | |
766 val = -val; | |
767 val--; | |
768 code = (val >> bit_size) + 1; | |
769 if(code<17){ | |
5210 | 770 len= ff_mpeg12_mbMotionVectorTable[code][1] + 1 + bit_size; |
5208 | 771 }else{ |
5210 | 772 len= ff_mpeg12_mbMotionVectorTable[16][1] + 2 + bit_size; |
5208 | 773 } |
774 } | |
775 | |
776 mv_penalty[f_code][mv+MAX_MV]= len; | |
777 } | |
778 } | |
779 | |
780 | |
781 for(f_code=MAX_FCODE; f_code>0; f_code--){ | |
782 for(mv=-(8<<f_code); mv<(8<<f_code); mv++){ | |
783 fcode_tab[mv+MAX_MV]= f_code; | |
784 } | |
785 } | |
786 } | |
787 s->me.mv_penalty= mv_penalty; | |
788 s->fcode_tab= fcode_tab; | |
789 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ | |
790 s->min_qcoeff=-255; | |
791 s->max_qcoeff= 255; | |
792 }else{ | |
793 s->min_qcoeff=-2047; | |
794 s->max_qcoeff= 2047; | |
795 } | |
796 if (s->intra_vlc_format) { | |
797 s->intra_ac_vlc_length= | |
798 s->intra_ac_vlc_last_length= uni_mpeg2_ac_vlc_len; | |
799 } else { | |
800 s->intra_ac_vlc_length= | |
801 s->intra_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; | |
802 } | |
803 s->inter_ac_vlc_length= | |
804 s->inter_ac_vlc_last_length= uni_mpeg1_ac_vlc_len; | |
805 } | |
806 | |
807 static inline void encode_dc(MpegEncContext *s, int diff, int component) | |
808 { | |
809 if(((unsigned) (diff+255)) >= 511){ | |
810 int index; | |
811 | |
812 if(diff<0){ | |
813 index= av_log2_16bit(-2*diff); | |
814 diff--; | |
815 }else{ | |
816 index= av_log2_16bit(2*diff); | |
817 } | |
818 if (component == 0) { | |
819 put_bits( | |
820 &s->pb, | |
5210 | 821 ff_mpeg12_vlc_dc_lum_bits[index] + index, |
822 (ff_mpeg12_vlc_dc_lum_code[index]<<index) + (diff & ((1 << index) - 1))); | |
5208 | 823 }else{ |
824 put_bits( | |
825 &s->pb, | |
5210 | 826 ff_mpeg12_vlc_dc_chroma_bits[index] + index, |
827 (ff_mpeg12_vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index) - 1))); | |
5208 | 828 } |
829 }else{ | |
830 if (component == 0) { | |
831 put_bits( | |
832 &s->pb, | |
833 mpeg1_lum_dc_uni[diff+255]&0xFF, | |
834 mpeg1_lum_dc_uni[diff+255]>>8); | |
835 } else { | |
836 put_bits( | |
837 &s->pb, | |
838 mpeg1_chr_dc_uni[diff+255]&0xFF, | |
839 mpeg1_chr_dc_uni[diff+255]>>8); | |
840 } | |
841 } | |
842 } | |
843 | |
844 static void mpeg1_encode_block(MpegEncContext *s, | |
845 DCTELEM *block, | |
846 int n) | |
847 { | |
848 int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign; | |
849 int code, component; | |
5210 | 850 const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc; |
5208 | 851 |
852 last_index = s->block_last_index[n]; | |
853 | |
854 /* DC coef */ | |
855 if (s->mb_intra) { | |
856 component = (n <= 3 ? 0 : (n&1) + 1); | |
857 dc = block[0]; /* overflow is impossible */ | |
858 diff = dc - s->last_dc[component]; | |
859 encode_dc(s, diff, component); | |
860 s->last_dc[component] = dc; | |
861 i = 1; | |
862 if (s->intra_vlc_format) | |
5210 | 863 table_vlc = ff_rl_mpeg2.table_vlc; |
5208 | 864 } else { |
865 /* encode the first coefficient : needs to be done here because | |
866 it is handled slightly differently */ | |
867 level = block[0]; | |
868 if (abs(level) == 1) { | |
869 code = ((uint32_t)level >> 31); /* the sign bit */ | |
870 put_bits(&s->pb, 2, code | 0x02); | |
871 i = 1; | |
872 } else { | |
873 i = 0; | |
874 last_non_zero = -1; | |
875 goto next_coef; | |
876 } | |
877 } | |
878 | |
879 /* now quantify & encode AC coefs */ | |
880 last_non_zero = i - 1; | |
881 | |
882 for(;i<=last_index;i++) { | |
883 j = s->intra_scantable.permutated[i]; | |
884 level = block[j]; | |
885 next_coef: | |
886 #if 0 | |
887 if (level != 0) | |
888 dprintf(s->avctx, "level[%d]=%d\n", i, level); | |
889 #endif | |
890 /* encode using VLC */ | |
891 if (level != 0) { | |
892 run = i - last_non_zero - 1; | |
893 | |
894 alevel= level; | |
895 MASK_ABS(sign, alevel) | |
896 sign&=1; | |
897 | |
898 if (alevel <= mpeg1_max_level[0][run]){ | |
899 code= mpeg1_index_run[0][run] + alevel - 1; | |
900 /* store the vlc & sign at once */ | |
901 put_bits(&s->pb, table_vlc[code][1]+1, (table_vlc[code][0]<<1) + sign); | |
902 } else { | |
903 /* escape seems to be pretty rare <5% so I do not optimize it */ | |
904 put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]); | |
905 /* escape: only clip in this case */ | |
906 put_bits(&s->pb, 6, run); | |
907 if(s->codec_id == CODEC_ID_MPEG1VIDEO){ | |
908 if (alevel < 128) { | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
909 put_sbits(&s->pb, 8, level); |
5208 | 910 } else { |
911 if (level < 0) { | |
912 put_bits(&s->pb, 16, 0x8001 + level + 255); | |
913 } else { | |
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, 16, level); |
5208 | 915 } |
916 } | |
917 }else{ | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7143
diff
changeset
|
918 put_sbits(&s->pb, 12, level); |
5208 | 919 } |
920 } | |
921 last_non_zero = i; | |
922 } | |
923 } | |
924 /* end of block */ | |
925 put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]); | |
926 } | |
927 | |
928 AVCodec mpeg1video_encoder = { | |
929 "mpeg1video", | |
930 CODEC_TYPE_VIDEO, | |
931 CODEC_ID_MPEG1VIDEO, | |
932 sizeof(MpegEncContext), | |
933 encode_init, | |
934 MPV_encode_picture, | |
935 MPV_encode_end, | |
936 .supported_framerates= ff_frame_rate_tab+1, | |
6788 | 937 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, |
5208 | 938 .capabilities= CODEC_CAP_DELAY, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6788
diff
changeset
|
939 .long_name= NULL_IF_CONFIG_SMALL("MPEG-1 video"), |
5208 | 940 }; |
941 | |
942 AVCodec mpeg2video_encoder = { | |
943 "mpeg2video", | |
944 CODEC_TYPE_VIDEO, | |
945 CODEC_ID_MPEG2VIDEO, | |
946 sizeof(MpegEncContext), | |
947 encode_init, | |
948 MPV_encode_picture, | |
949 MPV_encode_end, | |
950 .supported_framerates= ff_frame_rate_tab+1, | |
6788 | 951 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE}, |
5208 | 952 .capabilities= CODEC_CAP_DELAY, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6788
diff
changeset
|
953 .long_name= NULL_IF_CONFIG_SMALL("MPEG-2 video"), |
5208 | 954 }; |