GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* MPEG-1/2 encoder |
||
3 |
* Copyright (c) 2000,2001 Fabrice Bellard |
||
4 |
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
||
5 |
* |
||
6 |
* This file is part of FFmpeg. |
||
7 |
* |
||
8 |
* FFmpeg is free software; you can redistribute it and/or |
||
9 |
* modify it under the terms of the GNU Lesser General Public |
||
10 |
* License as published by the Free Software Foundation; either |
||
11 |
* version 2.1 of the License, or (at your option) any later version. |
||
12 |
* |
||
13 |
* FFmpeg is distributed in the hope that it will be useful, |
||
14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
16 |
* Lesser General Public License for more details. |
||
17 |
* |
||
18 |
* You should have received a copy of the GNU Lesser General Public |
||
19 |
* License along with FFmpeg; if not, write to the Free Software |
||
20 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
21 |
*/ |
||
22 |
|||
23 |
/** |
||
24 |
* @file |
||
25 |
* MPEG-1/2 encoder |
||
26 |
*/ |
||
27 |
|||
28 |
#include <stdint.h> |
||
29 |
|||
30 |
#include "config.h" |
||
31 |
#include "libavutil/attributes.h" |
||
32 |
#include "libavutil/avassert.h" |
||
33 |
#include "libavutil/log.h" |
||
34 |
#include "libavutil/opt.h" |
||
35 |
#include "libavutil/thread.h" |
||
36 |
#include "libavutil/timecode.h" |
||
37 |
#include "libavutil/stereo3d.h" |
||
38 |
|||
39 |
#include "avcodec.h" |
||
40 |
#include "bytestream.h" |
||
41 |
#include "mathops.h" |
||
42 |
#include "mpeg12.h" |
||
43 |
#include "mpeg12data.h" |
||
44 |
#include "mpegutils.h" |
||
45 |
#include "mpegvideo.h" |
||
46 |
#include "profiles.h" |
||
47 |
|||
48 |
#if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER |
||
49 |
static const uint8_t svcd_scan_offset_placeholder[] = { |
||
50 |
0x10, 0x0E, 0x00, 0x80, 0x81, 0x00, 0x80, |
||
51 |
0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
||
52 |
}; |
||
53 |
|||
54 |
static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1]; |
||
55 |
static uint8_t fcode_tab[MAX_MV * 2 + 1]; |
||
56 |
|||
57 |
static uint8_t uni_mpeg1_ac_vlc_len[64 * 64 * 2]; |
||
58 |
static uint8_t uni_mpeg2_ac_vlc_len[64 * 64 * 2]; |
||
59 |
|||
60 |
/* simple include everything table for dc, first byte is bits |
||
61 |
* 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 |
#define A53_MAX_CC_COUNT 0x1f |
||
69 |
#endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */ |
||
70 |
|||
71 |
96 |
av_cold void ff_mpeg1_init_uni_ac_vlc(const RLTable *rl, uint8_t *uni_ac_vlc_len) |
|
72 |
{ |
||
73 |
int i; |
||
74 |
|||
75 |
✓✓ | 12384 |
for (i = 0; i < 128; i++) { |
76 |
12288 |
int level = i - 64; |
|
77 |
int run; |
||
78 |
✓✓ | 12288 |
if (!level) |
79 |
96 |
continue; |
|
80 |
✓✓ | 792480 |
for (run = 0; run < 64; run++) { |
81 |
int len, code; |
||
82 |
780288 |
int alevel = FFABS(level); |
|
83 |
|||
84 |
✓✓ | 780288 |
if (alevel > rl->max_level[0][run]) |
85 |
758976 |
code = 111; /* rl->n */ |
|
86 |
else |
||
87 |
21312 |
code = rl->index_run[0][run] + alevel - 1; |
|
88 |
|||
89 |
✓✓ | 780288 |
if (code < 111) { /* rl->n */ |
90 |
/* length of VLC and sign */ |
||
91 |
21312 |
len = rl->table_vlc[code][1] + 1; |
|
92 |
} else { |
||
93 |
758976 |
len = rl->table_vlc[111 /* rl->n */][1] + 6; |
|
94 |
|||
95 |
✓✗ | 758976 |
if (alevel < 128) |
96 |
758976 |
len += 8; |
|
97 |
else |
||
98 |
len += 16; |
||
99 |
} |
||
100 |
|||
101 |
780288 |
uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len; |
|
102 |
} |
||
103 |
} |
||
104 |
96 |
} |
|
105 |
|||
106 |
#if CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER |
||
107 |
48 |
static int find_frame_rate_index(MpegEncContext *s) |
|
108 |
{ |
||
109 |
int i; |
||
110 |
48 |
AVRational bestq = (AVRational) {0, 0}; |
|
111 |
AVRational ext; |
||
112 |
48 |
AVRational target = av_inv_q(s->avctx->time_base); |
|
113 |
|||
114 |
✓✗ | 432 |
for (i = 1; i < 14; i++) { |
115 |
✓✗✓✓ |
432 |
if (s->avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL && |
116 |
i >= 9) |
||
117 |
48 |
break; |
|
118 |
|||
119 |
✓✓ | 1920 |
for (ext.num=1; ext.num <= 4; ext.num++) { |
120 |
✓✓ | 50688 |
for (ext.den=1; ext.den <= 32; ext.den++) { |
121 |
49152 |
AVRational q = av_mul_q(ext, ff_mpeg12_frame_rate_tab[i]); |
|
122 |
|||
123 |
✓✓✓✓ ✓✓ |
49152 |
if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO && (ext.den!=1 || ext.num!=1)) |
124 |
23608 |
continue; |
|
125 |
✓✓ | 37976 |
if (av_gcd(ext.den, ext.num) != 1) |
126 |
12432 |
continue; |
|
127 |
|||
128 |
✓✓ | 25544 |
if ( bestq.num==0 |
129 |
✓✓ | 25496 |
|| av_nearer_q(target, bestq, q) < 0 |
130 |
✓✓✓✓ ✗✓ |
25399 |
|| ext.num==1 && ext.den==1 && av_nearer_q(target, bestq, q) == 0) { |
131 |
145 |
bestq = q; |
|
132 |
145 |
s->frame_rate_index = i; |
|
133 |
145 |
s->mpeg2_frame_rate_ext.num = ext.num; |
|
134 |
145 |
s->mpeg2_frame_rate_ext.den = ext.den; |
|
135 |
} |
||
136 |
} |
||
137 |
} |
||
138 |
} |
||
139 |
|||
140 |
✗✓ | 48 |
if (av_cmp_q(target, bestq)) |
141 |
return -1; |
||
142 |
else |
||
143 |
48 |
return 0; |
|
144 |
} |
||
145 |
|||
146 |
48 |
static av_cold int encode_init(AVCodecContext *avctx) |
|
147 |
{ |
||
148 |
int ret; |
||
149 |
48 |
MpegEncContext *s = avctx->priv_data; |
|
150 |
|||
151 |
✗✓ | 48 |
if ((ret = ff_mpv_encode_init(avctx)) < 0) |
152 |
return ret; |
||
153 |
|||
154 |
✗✓ | 48 |
if (find_frame_rate_index(s) < 0) { |
155 |
if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { |
||
156 |
av_log(avctx, AV_LOG_ERROR, "MPEG-1/2 does not support %d/%d fps\n", |
||
157 |
avctx->time_base.den, avctx->time_base.num); |
||
158 |
return AVERROR(EINVAL); |
||
159 |
} else { |
||
160 |
av_log(avctx, AV_LOG_INFO, |
||
161 |
"MPEG-1/2 does not support %d/%d fps, there may be AV sync issues\n", |
||
162 |
avctx->time_base.den, avctx->time_base.num); |
||
163 |
} |
||
164 |
} |
||
165 |
|||
166 |
✓✗ | 48 |
if (avctx->profile == FF_PROFILE_UNKNOWN) { |
167 |
✗✓ | 48 |
if (avctx->level != FF_LEVEL_UNKNOWN) { |
168 |
av_log(avctx, AV_LOG_ERROR, "Set profile and level\n"); |
||
169 |
return AVERROR(EINVAL); |
||
170 |
} |
||
171 |
/* Main or 4:2:2 */ |
||
172 |
✓✓ | 48 |
avctx->profile = s->chroma_format == CHROMA_420 ? FF_PROFILE_MPEG2_MAIN : FF_PROFILE_MPEG2_422; |
173 |
} |
||
174 |
|||
175 |
✓✗ | 48 |
if (avctx->level == FF_LEVEL_UNKNOWN) { |
176 |
✓✓ | 48 |
if (avctx->profile == FF_PROFILE_MPEG2_422) { /* 4:2:2 */ |
177 |
✓✗✓✗ |
5 |
if (avctx->width <= 720 && avctx->height <= 608) |
178 |
5 |
avctx->level = 5; /* Main */ |
|
179 |
else |
||
180 |
avctx->level = 2; /* High */ |
||
181 |
} else { |
||
182 |
✓✗✗✓ |
43 |
if (avctx->profile != FF_PROFILE_MPEG2_HIGH && s->chroma_format != CHROMA_420) { |
183 |
av_log(avctx, AV_LOG_ERROR, |
||
184 |
"Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n"); |
||
185 |
return AVERROR(EINVAL); |
||
186 |
} |
||
187 |
✓✗✓✗ |
43 |
if (avctx->width <= 720 && avctx->height <= 576) |
188 |
43 |
avctx->level = 8; /* Main */ |
|
189 |
else if (avctx->width <= 1440) |
||
190 |
avctx->level = 6; /* High 1440 */ |
||
191 |
else |
||
192 |
avctx->level = 4; /* High */ |
||
193 |
} |
||
194 |
} |
||
195 |
|||
196 |
✗✓✗✗ |
48 |
if ((avctx->width & 0xFFF) == 0 && (avctx->height & 0xFFF) == 1) { |
197 |
av_log(avctx, AV_LOG_ERROR, "Width / Height is invalid for MPEG2\n"); |
||
198 |
return AVERROR(EINVAL); |
||
199 |
} |
||
200 |
|||
201 |
✓✗ | 48 |
if (s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) { |
202 |
✓✗✗✓ |
48 |
if ((avctx->width & 0xFFF) == 0 || (avctx->height & 0xFFF) == 0) { |
203 |
av_log(avctx, AV_LOG_ERROR, "Width or Height are not allowed to be multiples of 4096\n" |
||
204 |
"add '-strict %d' if you want to use them anyway.\n", FF_COMPLIANCE_UNOFFICIAL); |
||
205 |
return AVERROR(EINVAL); |
||
206 |
} |
||
207 |
} |
||
208 |
|||
209 |
✓✗✗✓ |
48 |
s->drop_frame_timecode = s->drop_frame_timecode || !!(avctx->flags2 & AV_CODEC_FLAG2_DROP_FRAME_TIMECODE); |
210 |
✗✓ | 48 |
if (s->drop_frame_timecode) |
211 |
s->tc.flags |= AV_TIMECODE_FLAG_DROPFRAME; |
||
212 |
✗✓✗✗ |
48 |
if (s->drop_frame_timecode && s->frame_rate_index != 4) { |
213 |
av_log(avctx, AV_LOG_ERROR, |
||
214 |
"Drop frame time code only allowed with 1001/30000 fps\n"); |
||
215 |
return AVERROR(EINVAL); |
||
216 |
} |
||
217 |
|||
218 |
#if FF_API_PRIVATE_OPT |
||
219 |
FF_DISABLE_DEPRECATION_WARNINGS |
||
220 |
✓✗ | 48 |
if (avctx->timecode_frame_start) |
221 |
48 |
s->timecode_frame_start = avctx->timecode_frame_start; |
|
222 |
FF_ENABLE_DEPRECATION_WARNINGS |
||
223 |
#endif |
||
224 |
|||
225 |
✓✓ | 48 |
if (s->tc_opt_str) { |
226 |
6 |
AVRational rate = ff_mpeg12_frame_rate_tab[s->frame_rate_index]; |
|
227 |
6 |
int ret = av_timecode_init_from_string(&s->tc, rate, s->tc_opt_str, s); |
|
228 |
✗✓ | 6 |
if (ret < 0) |
229 |
return ret; |
||
230 |
6 |
s->drop_frame_timecode = !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME); |
|
231 |
6 |
s->timecode_frame_start = s->tc.start; |
|
232 |
} else { |
||
233 |
42 |
s->timecode_frame_start = 0; // default is -1 |
|
234 |
} |
||
235 |
|||
236 |
48 |
return 0; |
|
237 |
} |
||
238 |
|||
239 |
294050 |
static void put_header(MpegEncContext *s, int header) |
|
240 |
{ |
||
241 |
294050 |
align_put_bits(&s->pb); |
|
242 |
294050 |
put_bits(&s->pb, 16, header >> 16); |
|
243 |
294050 |
put_sbits(&s->pb, 16, header); |
|
244 |
294050 |
} |
|
245 |
|||
246 |
/* put sequence header if needed */ |
||
247 |
2240 |
static void mpeg1_encode_sequence_header(MpegEncContext *s) |
|
248 |
{ |
||
249 |
unsigned int vbv_buffer_size, fps, v; |
||
250 |
int i, constraint_parameter_flag; |
||
251 |
uint64_t time_code; |
||
252 |
2240 |
int64_t best_aspect_error = INT64_MAX; |
|
253 |
2240 |
AVRational aspect_ratio = s->avctx->sample_aspect_ratio; |
|
254 |
|||
255 |
✗✓✗✗ |
2240 |
if (aspect_ratio.num == 0 || aspect_ratio.den == 0) |
256 |
2240 |
aspect_ratio = (AVRational){1,1}; // pixel aspect 1.1 (VGA) |
|
257 |
|||
258 |
✓✓ | 2240 |
if (s->current_picture.f->key_frame) { |
259 |
380 |
AVRational framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index]; |
|
260 |
|||
261 |
/* MPEG-1 header repeated every GOP */ |
||
262 |
380 |
put_header(s, SEQ_START_CODE); |
|
263 |
|||
264 |
380 |
put_sbits(&s->pb, 12, s->width & 0xFFF); |
|
265 |
380 |
put_sbits(&s->pb, 12, s->height & 0xFFF); |
|
266 |
|||
267 |
✓✓ | 5700 |
for (i = 1; i < 15; i++) { |
268 |
5320 |
int64_t error = aspect_ratio.num * (1LL<<32) / aspect_ratio.den; |
|
269 |
✓✓✓✓ |
5320 |
if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || i <= 1) |
270 |
1069 |
error -= (1LL<<32) / ff_mpeg1_aspect[i]; |
|
271 |
else |
||
272 |
4251 |
error -= (1LL<<32)*ff_mpeg2_aspect[i].num * s->height / s->width / ff_mpeg2_aspect[i].den; |
|
273 |
|||
274 |
5320 |
error = FFABS(error); |
|
275 |
|||
276 |
✓✓ | 5320 |
if (error - 2 <= best_aspect_error) { |
277 |
380 |
best_aspect_error = error; |
|
278 |
380 |
s->aspect_ratio_info = i; |
|
279 |
} |
||
280 |
} |
||
281 |
|||
282 |
380 |
put_bits(&s->pb, 4, s->aspect_ratio_info); |
|
283 |
380 |
put_bits(&s->pb, 4, s->frame_rate_index); |
|
284 |
|||
285 |
✓✓ | 380 |
if (s->avctx->rc_max_rate) { |
286 |
150 |
v = (s->avctx->rc_max_rate + 399) / 400; |
|
287 |
✗✓✗✗ |
150 |
if (v > 0x3ffff && s->codec_id == AV_CODEC_ID_MPEG1VIDEO) |
288 |
v = 0x3ffff; |
||
289 |
} else { |
||
290 |
230 |
v = 0x3FFFF; |
|
291 |
} |
||
292 |
|||
293 |
✓✓ | 380 |
if (s->avctx->rc_buffer_size) |
294 |
150 |
vbv_buffer_size = s->avctx->rc_buffer_size; |
|
295 |
else |
||
296 |
/* VBV calculation: Scaled so that a VCD has the proper |
||
297 |
* VBV size of 40 kilobytes */ |
||
298 |
230 |
vbv_buffer_size = ((20 * s->bit_rate) / (1151929 / 2)) * 8 * 1024; |
|
299 |
380 |
vbv_buffer_size = (vbv_buffer_size + 16383) / 16384; |
|
300 |
|||
301 |
380 |
put_sbits(&s->pb, 18, v); |
|
302 |
380 |
put_bits(&s->pb, 1, 1); // marker |
|
303 |
380 |
put_sbits(&s->pb, 10, vbv_buffer_size); |
|
304 |
|||
305 |
380 |
constraint_parameter_flag = |
|
306 |
760 |
s->width <= 768 && |
|
307 |
✓✓ | 380 |
s->height <= 576 && |
308 |
✓✓ | 230 |
s->mb_width * s->mb_height <= 396 && |
309 |
✓✓ | 221 |
s->mb_width * s->mb_height * framerate.num <= 396 * 25 * framerate.den && |
310 |
✓✗ | 215 |
framerate.num <= framerate.den * 30 && |
311 |
✗✓ | 215 |
s->avctx->me_range && |
312 |
s->avctx->me_range < 128 && |
||
313 |
vbv_buffer_size <= 20 && |
||
314 |
✓✗ | 760 |
v <= 1856000 / 400 && |
315 |
s->codec_id == AV_CODEC_ID_MPEG1VIDEO; |
||
316 |
|||
317 |
380 |
put_bits(&s->pb, 1, constraint_parameter_flag); |
|
318 |
|||
319 |
380 |
ff_write_quant_matrix(&s->pb, s->avctx->intra_matrix); |
|
320 |
380 |
ff_write_quant_matrix(&s->pb, s->avctx->inter_matrix); |
|
321 |
|||
322 |
✓✓ | 380 |
if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) { |
323 |
AVFrameSideData *side_data; |
||
324 |
327 |
int width = s->width; |
|
325 |
327 |
int height = s->height; |
|
326 |
int use_seq_disp_ext; |
||
327 |
|||
328 |
327 |
put_header(s, EXT_START_CODE); |
|
329 |
327 |
put_bits(&s->pb, 4, 1); // seq ext |
|
330 |
|||
331 |
327 |
put_bits(&s->pb, 1, s->avctx->profile == FF_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile |
|
332 |
|||
333 |
327 |
put_bits(&s->pb, 3, s->avctx->profile); // profile |
|
334 |
327 |
put_bits(&s->pb, 4, s->avctx->level); // level |
|
335 |
|||
336 |
327 |
put_bits(&s->pb, 1, s->progressive_sequence); |
|
337 |
327 |
put_bits(&s->pb, 2, s->chroma_format); |
|
338 |
327 |
put_bits(&s->pb, 2, s->width >> 12); |
|
339 |
327 |
put_bits(&s->pb, 2, s->height >> 12); |
|
340 |
327 |
put_bits(&s->pb, 12, v >> 18); // bitrate ext |
|
341 |
327 |
put_bits(&s->pb, 1, 1); // marker |
|
342 |
327 |
put_bits(&s->pb, 8, vbv_buffer_size >> 10); // vbv buffer ext |
|
343 |
327 |
put_bits(&s->pb, 1, s->low_delay); |
|
344 |
327 |
put_bits(&s->pb, 2, s->mpeg2_frame_rate_ext.num-1); // frame_rate_ext_n |
|
345 |
327 |
put_bits(&s->pb, 5, s->mpeg2_frame_rate_ext.den-1); // frame_rate_ext_d |
|
346 |
|||
347 |
327 |
side_data = av_frame_get_side_data(s->current_picture_ptr->f, AV_FRAME_DATA_PANSCAN); |
|
348 |
✗✓ | 327 |
if (side_data) { |
349 |
AVPanScan *pan_scan = (AVPanScan *)side_data->data; |
||
350 |
if (pan_scan->width && pan_scan->height) { |
||
351 |
width = pan_scan->width >> 4; |
||
352 |
height = pan_scan->height >> 4; |
||
353 |
} |
||
354 |
} |
||
355 |
|||
356 |
981 |
use_seq_disp_ext = (width != s->width || |
|
357 |
✓✗ | 327 |
height != s->height || |
358 |
✓✗ | 327 |
s->avctx->color_primaries != AVCOL_PRI_UNSPECIFIED || |
359 |
✓✗ | 327 |
s->avctx->color_trc != AVCOL_TRC_UNSPECIFIED || |
360 |
✓✗✓✗ |
981 |
s->avctx->colorspace != AVCOL_SPC_UNSPECIFIED || |
361 |
✗✓ | 327 |
s->video_format != VIDEO_FORMAT_UNSPECIFIED); |
362 |
|||
363 |
✓✗✓✗ ✗✓ |
327 |
if (s->seq_disp_ext == 1 || (s->seq_disp_ext == -1 && use_seq_disp_ext)) { |
364 |
put_header(s, EXT_START_CODE); |
||
365 |
put_bits(&s->pb, 4, 2); // sequence display extension |
||
366 |
put_bits(&s->pb, 3, s->video_format); // video_format |
||
367 |
put_bits(&s->pb, 1, 1); // colour_description |
||
368 |
put_bits(&s->pb, 8, s->avctx->color_primaries); // colour_primaries |
||
369 |
put_bits(&s->pb, 8, s->avctx->color_trc); // transfer_characteristics |
||
370 |
put_bits(&s->pb, 8, s->avctx->colorspace); // matrix_coefficients |
||
371 |
put_bits(&s->pb, 14, width); // display_horizontal_size |
||
372 |
put_bits(&s->pb, 1, 1); // marker_bit |
||
373 |
put_bits(&s->pb, 14, height); // display_vertical_size |
||
374 |
put_bits(&s->pb, 3, 0); // remaining 3 bits are zero padding |
||
375 |
} |
||
376 |
} |
||
377 |
|||
378 |
380 |
put_header(s, GOP_START_CODE); |
|
379 |
380 |
put_bits(&s->pb, 1, s->drop_frame_timecode); // drop frame flag |
|
380 |
/* time code: we must convert from the real frame rate to a |
||
381 |
* fake MPEG frame rate in case of low frame rate */ |
||
382 |
380 |
fps = (framerate.num + framerate.den / 2) / framerate.den; |
|
383 |
380 |
time_code = s->current_picture_ptr->f->coded_picture_number + |
|
384 |
380 |
s->timecode_frame_start; |
|
385 |
|||
386 |
380 |
s->gop_picture_number = s->current_picture_ptr->f->coded_picture_number; |
|
387 |
|||
388 |
✗✓ | 380 |
av_assert0(s->drop_frame_timecode == !!(s->tc.flags & AV_TIMECODE_FLAG_DROPFRAME)); |
389 |
✓✓ | 380 |
if (s->drop_frame_timecode) |
390 |
9 |
time_code = av_timecode_adjust_ntsc_framenum2(time_code, fps); |
|
391 |
|||
392 |
380 |
put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24)); |
|
393 |
380 |
put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60)); |
|
394 |
380 |
put_bits(&s->pb, 1, 1); |
|
395 |
380 |
put_bits(&s->pb, 6, (uint32_t)((time_code / fps) % 60)); |
|
396 |
380 |
put_bits(&s->pb, 6, (uint32_t)((time_code % fps))); |
|
397 |
✓✗✓✓ ✓✓ |
380 |
put_bits(&s->pb, 1, !!(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) || s->intra_only || !s->gop_picture_number); |
398 |
380 |
put_bits(&s->pb, 1, 0); // broken link |
|
399 |
} |
||
400 |
2240 |
} |
|
401 |
|||
402 |
1553801 |
static inline void encode_mb_skip_run(MpegEncContext *s, int run) |
|
403 |
{ |
||
404 |
✓✓ | 1622203 |
while (run >= 33) { |
405 |
68402 |
put_bits(&s->pb, 11, 0x008); |
|
406 |
68402 |
run -= 33; |
|
407 |
} |
||
408 |
1553801 |
put_bits(&s->pb, ff_mpeg12_mbAddrIncrTable[run][1], |
|
409 |
1553801 |
ff_mpeg12_mbAddrIncrTable[run][0]); |
|
410 |
1553801 |
} |
|
411 |
|||
412 |
474731 |
static av_always_inline void put_qscale(MpegEncContext *s) |
|
413 |
{ |
||
414 |
474731 |
put_bits(&s->pb, 5, s->qscale); |
|
415 |
474731 |
} |
|
416 |
|||
417 |
288963 |
void ff_mpeg1_encode_slice_header(MpegEncContext *s) |
|
418 |
{ |
||
419 |
✓✓✗✓ |
288963 |
if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->height > 2800) { |
420 |
put_header(s, SLICE_MIN_START_CODE + (s->mb_y & 127)); |
||
421 |
/* slice_vertical_position_extension */ |
||
422 |
put_bits(&s->pb, 3, s->mb_y >> 7); |
||
423 |
} else { |
||
424 |
288963 |
put_header(s, SLICE_MIN_START_CODE + s->mb_y); |
|
425 |
} |
||
426 |
288963 |
put_qscale(s); |
|
427 |
/* slice extra information */ |
||
428 |
288963 |
put_bits(&s->pb, 1, 0); |
|
429 |
288963 |
} |
|
430 |
|||
431 |
2240 |
void ff_mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) |
|
432 |
{ |
||
433 |
AVFrameSideData *side_data; |
||
434 |
2240 |
mpeg1_encode_sequence_header(s); |
|
435 |
|||
436 |
/* MPEG-1 picture header */ |
||
437 |
2240 |
put_header(s, PICTURE_START_CODE); |
|
438 |
/* temporal reference */ |
||
439 |
|||
440 |
// RAL: s->picture_number instead of s->fake_picture_number |
||
441 |
2240 |
put_bits(&s->pb, 10, |
|
442 |
2240 |
(s->picture_number - s->gop_picture_number) & 0x3ff); |
|
443 |
2240 |
put_bits(&s->pb, 3, s->pict_type); |
|
444 |
|||
445 |
2240 |
s->vbv_delay_ptr = s->pb.buf + put_bits_count(&s->pb) / 8; |
|
446 |
2240 |
put_bits(&s->pb, 16, 0xFFFF); /* vbv_delay */ |
|
447 |
|||
448 |
// RAL: Forward f_code also needed for B-frames |
||
449 |
✓✓ | 2240 |
if (s->pict_type == AV_PICTURE_TYPE_P || |
450 |
✓✓ | 1087 |
s->pict_type == AV_PICTURE_TYPE_B) { |
451 |
1860 |
put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
|
452 |
✓✓ | 1860 |
if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) |
453 |
427 |
put_bits(&s->pb, 3, s->f_code); /* forward_f_code */ |
|
454 |
else |
||
455 |
1433 |
put_bits(&s->pb, 3, 7); /* forward_f_code */ |
|
456 |
} |
||
457 |
|||
458 |
// RAL: Backward f_code necessary for B-frames |
||
459 |
✓✓ | 2240 |
if (s->pict_type == AV_PICTURE_TYPE_B) { |
460 |
707 |
put_bits(&s->pb, 1, 0); /* half pel coordinates */ |
|
461 |
✓✓ | 707 |
if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) |
462 |
144 |
put_bits(&s->pb, 3, s->b_code); /* backward_f_code */ |
|
463 |
else |
||
464 |
563 |
put_bits(&s->pb, 3, 7); /* backward_f_code */ |
|
465 |
} |
||
466 |
|||
467 |
2240 |
put_bits(&s->pb, 1, 0); /* extra bit picture */ |
|
468 |
|||
469 |
2240 |
s->frame_pred_frame_dct = 1; |
|
470 |
✓✓ | 2240 |
if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) { |
471 |
1760 |
put_header(s, EXT_START_CODE); |
|
472 |
1760 |
put_bits(&s->pb, 4, 8); /* pic ext */ |
|
473 |
✓✓ | 1760 |
if (s->pict_type == AV_PICTURE_TYPE_P || |
474 |
✓✓ | 890 |
s->pict_type == AV_PICTURE_TYPE_B) { |
475 |
1433 |
put_bits(&s->pb, 4, s->f_code); |
|
476 |
1433 |
put_bits(&s->pb, 4, s->f_code); |
|
477 |
} else { |
||
478 |
327 |
put_bits(&s->pb, 8, 255); |
|
479 |
} |
||
480 |
✓✓ | 1760 |
if (s->pict_type == AV_PICTURE_TYPE_B) { |
481 |
563 |
put_bits(&s->pb, 4, s->b_code); |
|
482 |
563 |
put_bits(&s->pb, 4, s->b_code); |
|
483 |
} else { |
||
484 |
1197 |
put_bits(&s->pb, 8, 255); |
|
485 |
} |
||
486 |
1760 |
put_bits(&s->pb, 2, s->intra_dc_precision); |
|
487 |
|||
488 |
✗✓ | 1760 |
av_assert0(s->picture_structure == PICT_FRAME); |
489 |
1760 |
put_bits(&s->pb, 2, s->picture_structure); |
|
490 |
✓✓ | 1760 |
if (s->progressive_sequence) |
491 |
810 |
put_bits(&s->pb, 1, 0); /* no repeat */ |
|
492 |
else |
||
493 |
950 |
put_bits(&s->pb, 1, s->current_picture_ptr->f->top_field_first); |
|
494 |
/* XXX: optimize the generation of this flag with entropy measures */ |
||
495 |
1760 |
s->frame_pred_frame_dct = s->progressive_sequence; |
|
496 |
|||
497 |
1760 |
put_bits(&s->pb, 1, s->frame_pred_frame_dct); |
|
498 |
1760 |
put_bits(&s->pb, 1, s->concealment_motion_vectors); |
|
499 |
1760 |
put_bits(&s->pb, 1, s->q_scale_type); |
|
500 |
1760 |
put_bits(&s->pb, 1, s->intra_vlc_format); |
|
501 |
1760 |
put_bits(&s->pb, 1, s->alternate_scan); |
|
502 |
1760 |
put_bits(&s->pb, 1, s->repeat_first_field); |
|
503 |
1760 |
s->progressive_frame = s->progressive_sequence; |
|
504 |
/* chroma_420_type */ |
||
505 |
✓✓ | 3170 |
put_bits(&s->pb, 1, s->chroma_format == |
506 |
1410 |
CHROMA_420 ? s->progressive_frame : 0); |
|
507 |
1760 |
put_bits(&s->pb, 1, s->progressive_frame); |
|
508 |
1760 |
put_bits(&s->pb, 1, 0); /* composite_display_flag */ |
|
509 |
} |
||
510 |
✗✓ | 2240 |
if (s->scan_offset) { |
511 |
int i; |
||
512 |
|||
513 |
put_header(s, USER_START_CODE); |
||
514 |
for (i = 0; i < sizeof(svcd_scan_offset_placeholder); i++) |
||
515 |
put_bits(&s->pb, 8, svcd_scan_offset_placeholder[i]); |
||
516 |
} |
||
517 |
2240 |
side_data = av_frame_get_side_data(s->current_picture_ptr->f, |
|
518 |
AV_FRAME_DATA_STEREO3D); |
||
519 |
✗✓ | 2240 |
if (side_data) { |
520 |
AVStereo3D *stereo = (AVStereo3D *)side_data->data; |
||
521 |
uint8_t fpa_type; |
||
522 |
|||
523 |
switch (stereo->type) { |
||
524 |
case AV_STEREO3D_SIDEBYSIDE: |
||
525 |
fpa_type = 0x03; |
||
526 |
break; |
||
527 |
case AV_STEREO3D_TOPBOTTOM: |
||
528 |
fpa_type = 0x04; |
||
529 |
break; |
||
530 |
case AV_STEREO3D_2D: |
||
531 |
fpa_type = 0x08; |
||
532 |
break; |
||
533 |
case AV_STEREO3D_SIDEBYSIDE_QUINCUNX: |
||
534 |
fpa_type = 0x23; |
||
535 |
break; |
||
536 |
default: |
||
537 |
fpa_type = 0; |
||
538 |
break; |
||
539 |
} |
||
540 |
|||
541 |
if (fpa_type != 0) { |
||
542 |
put_header(s, USER_START_CODE); |
||
543 |
put_bits(&s->pb, 8, 'J'); // S3D_video_format_signaling_identifier |
||
544 |
put_bits(&s->pb, 8, 'P'); |
||
545 |
put_bits(&s->pb, 8, '3'); |
||
546 |
put_bits(&s->pb, 8, 'D'); |
||
547 |
put_bits(&s->pb, 8, 0x03); // S3D_video_format_length |
||
548 |
|||
549 |
put_bits(&s->pb, 1, 1); // reserved_bit |
||
550 |
put_bits(&s->pb, 7, fpa_type); // S3D_video_format_type |
||
551 |
put_bits(&s->pb, 8, 0x04); // reserved_data[0] |
||
552 |
put_bits(&s->pb, 8, 0xFF); // reserved_data[1] |
||
553 |
} |
||
554 |
} |
||
555 |
|||
556 |
✓✓✓✗ |
2240 |
if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->a53_cc) { |
557 |
1760 |
side_data = av_frame_get_side_data(s->current_picture_ptr->f, |
|
558 |
AV_FRAME_DATA_A53_CC); |
||
559 |
✗✓ | 1760 |
if (side_data) { |
560 |
if (side_data->size <= A53_MAX_CC_COUNT * 3 && side_data->size % 3 == 0) { |
||
561 |
int i = 0; |
||
562 |
|||
563 |
put_header (s, USER_START_CODE); |
||
564 |
|||
565 |
put_bits(&s->pb, 8, 'G'); // user_identifier |
||
566 |
put_bits(&s->pb, 8, 'A'); |
||
567 |
put_bits(&s->pb, 8, '9'); |
||
568 |
put_bits(&s->pb, 8, '4'); |
||
569 |
put_bits(&s->pb, 8, 3); // user_data_type_code |
||
570 |
put_bits(&s->pb, 8, |
||
571 |
(side_data->size / 3 & A53_MAX_CC_COUNT) | 0x40); // flags, cc_count |
||
572 |
put_bits(&s->pb, 8, 0xff); // em_data |
||
573 |
|||
574 |
for (i = 0; i < side_data->size; i++) |
||
575 |
put_bits(&s->pb, 8, side_data->data[i]); |
||
576 |
|||
577 |
put_bits(&s->pb, 8, 0xff); // marker_bits |
||
578 |
} else { |
||
579 |
av_log(s->avctx, AV_LOG_WARNING, |
||
580 |
"Warning Closed Caption size (%d) can not exceed 93 bytes " |
||
581 |
"and must be a multiple of 3\n", side_data->size); |
||
582 |
} |
||
583 |
} |
||
584 |
} |
||
585 |
|||
586 |
2240 |
s->mb_y = 0; |
|
587 |
2240 |
ff_mpeg1_encode_slice_header(s); |
|
588 |
2240 |
} |
|
589 |
|||
590 |
1294772 |
static inline void put_mb_modes(MpegEncContext *s, int n, int bits, |
|
591 |
int has_mv, int field_motion) |
||
592 |
{ |
||
593 |
1294772 |
put_bits(&s->pb, n, bits); |
|
594 |
✓✓ | 1294772 |
if (!s->frame_pred_frame_dct) { |
595 |
✓✓ | 702603 |
if (has_mv) |
596 |
/* motion_type: frame/field */ |
||
597 |
365122 |
put_bits(&s->pb, 2, 2 - field_motion); |
|
598 |
702603 |
put_bits(&s->pb, 1, s->interlaced_dct); |
|
599 |
} |
||
600 |
1294772 |
} |
|
601 |
|||
602 |
// RAL: Parameter added: f_or_b_code |
||
603 |
2963288 |
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) |
|
604 |
{ |
||
605 |
✓✓ | 2963288 |
if (val == 0) { |
606 |
/* zero vector */ |
||
607 |
1169562 |
put_bits(&s->pb, |
|
608 |
1169562 |
ff_mpeg12_mbMotionVectorTable[0][1], |
|
609 |
1169562 |
ff_mpeg12_mbMotionVectorTable[0][0]); |
|
610 |
} else { |
||
611 |
int code, sign, bits; |
||
612 |
1793726 |
int bit_size = f_or_b_code - 1; |
|
613 |
1793726 |
int range = 1 << bit_size; |
|
614 |
/* modulo encoding */ |
||
615 |
1793726 |
val = sign_extend(val, 5 + bit_size); |
|
616 |
|||
617 |
✓✓ | 1793726 |
if (val >= 0) { |
618 |
874482 |
val--; |
|
619 |
874482 |
code = (val >> bit_size) + 1; |
|
620 |
874482 |
bits = val & (range - 1); |
|
621 |
874482 |
sign = 0; |
|
622 |
} else { |
||
623 |
919244 |
val = -val; |
|
624 |
919244 |
val--; |
|
625 |
919244 |
code = (val >> bit_size) + 1; |
|
626 |
919244 |
bits = val & (range - 1); |
|
627 |
919244 |
sign = 1; |
|
628 |
} |
||
629 |
|||
630 |
av_assert2(code > 0 && code <= 16); |
||
631 |
|||
632 |
1793726 |
put_bits(&s->pb, |
|
633 |
1793726 |
ff_mpeg12_mbMotionVectorTable[code][1], |
|
634 |
1793726 |
ff_mpeg12_mbMotionVectorTable[code][0]); |
|
635 |
|||
636 |
1793726 |
put_bits(&s->pb, 1, sign); |
|
637 |
✓✓ | 1793726 |
if (bit_size > 0) |
638 |
1248476 |
put_bits(&s->pb, bit_size, bits); |
|
639 |
} |
||
640 |
2963288 |
} |
|
641 |
|||
642 |
3163394 |
static inline void encode_dc(MpegEncContext *s, int diff, int component) |
|
643 |
{ |
||
644 |
3163394 |
unsigned int diff_u = diff + 255; |
|
645 |
✓✓ | 3163394 |
if (diff_u >= 511) { |
646 |
int index; |
||
647 |
|||
648 |
✓✓ | 162210 |
if (diff < 0) { |
649 |
113286 |
index = av_log2_16bit(-2 * diff); |
|
650 |
113286 |
diff--; |
|
651 |
} else { |
||
652 |
48924 |
index = av_log2_16bit(2 * diff); |
|
653 |
} |
||
654 |
✓✓ | 162210 |
if (component == 0) |
655 |
91380 |
put_bits(&s->pb, |
|
656 |
91380 |
ff_mpeg12_vlc_dc_lum_bits[index] + index, |
|
657 |
91380 |
(ff_mpeg12_vlc_dc_lum_code[index] << index) + |
|
658 |
91380 |
av_mod_uintp2(diff, index)); |
|
659 |
else |
||
660 |
70830 |
put_bits(&s->pb, |
|
661 |
70830 |
ff_mpeg12_vlc_dc_chroma_bits[index] + index, |
|
662 |
70830 |
(ff_mpeg12_vlc_dc_chroma_code[index] << index) + |
|
663 |
70830 |
av_mod_uintp2(diff, index)); |
|
664 |
} else { |
||
665 |
✓✓ | 3001184 |
if (component == 0) |
666 |
1623536 |
put_bits(&s->pb, |
|
667 |
1623536 |
mpeg1_lum_dc_uni[diff + 255] & 0xFF, |
|
668 |
1623536 |
mpeg1_lum_dc_uni[diff + 255] >> 8); |
|
669 |
else |
||
670 |
1377648 |
put_bits(&s->pb, |
|
671 |
1377648 |
mpeg1_chr_dc_uni[diff + 255] & 0xFF, |
|
672 |
1377648 |
mpeg1_chr_dc_uni[diff + 255] >> 8); |
|
673 |
} |
||
674 |
3163394 |
} |
|
675 |
|||
676 |
6384584 |
static void mpeg1_encode_block(MpegEncContext *s, int16_t *block, int n) |
|
677 |
{ |
||
678 |
int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign; |
||
679 |
int code, component; |
||
680 |
6384584 |
const uint16_t (*table_vlc)[2] = ff_rl_mpeg1.table_vlc; |
|
681 |
|||
682 |
6384584 |
last_index = s->block_last_index[n]; |
|
683 |
|||
684 |
/* DC coef */ |
||
685 |
✓✓ | 6384584 |
if (s->mb_intra) { |
686 |
✓✓ | 3163394 |
component = (n <= 3 ? 0 : (n & 1) + 1); |
687 |
3163394 |
dc = block[0]; /* overflow is impossible */ |
|
688 |
3163394 |
diff = dc - s->last_dc[component]; |
|
689 |
3163394 |
encode_dc(s, diff, component); |
|
690 |
3163394 |
s->last_dc[component] = dc; |
|
691 |
3163394 |
i = 1; |
|
692 |
✓✓ | 3163394 |
if (s->intra_vlc_format) |
693 |
2643692 |
table_vlc = ff_rl_mpeg2.table_vlc; |
|
694 |
} else { |
||
695 |
/* encode the first coefficient: needs to be done here because |
||
696 |
* it is handled slightly differently */ |
||
697 |
3221190 |
level = block[0]; |
|
698 |
✓✓ | 3221190 |
if (abs(level) == 1) { |
699 |
942621 |
code = ((uint32_t)level >> 31); /* the sign bit */ |
|
700 |
942621 |
put_bits(&s->pb, 2, code | 0x02); |
|
701 |
942621 |
i = 1; |
|
702 |
} else { |
||
703 |
2278569 |
i = 0; |
|
704 |
2278569 |
last_non_zero = -1; |
|
705 |
2278569 |
goto next_coef; |
|
706 |
} |
||
707 |
} |
||
708 |
|||
709 |
/* now quantify & encode AC coefs */ |
||
710 |
4106015 |
last_non_zero = i - 1; |
|
711 |
|||
712 |
✓✓ | 162593954 |
for (; i <= last_index; i++) { |
713 |
156209370 |
j = s->intra_scantable.permutated[i]; |
|
714 |
156209370 |
level = block[j]; |
|
715 |
|||
716 |
158487939 |
next_coef: |
|
717 |
/* encode using VLC */ |
||
718 |
✓✓ | 158487939 |
if (level != 0) { |
719 |
65399778 |
run = i - last_non_zero - 1; |
|
720 |
|||
721 |
65399778 |
alevel = level; |
|
722 |
65399778 |
MASK_ABS(sign, alevel); |
|
723 |
65399778 |
sign &= 1; |
|
724 |
|||
725 |
✓✓ | 65399778 |
if (alevel <= mpeg1_max_level[0][run]) { |
726 |
63333400 |
code = mpeg1_index_run[0][run] + alevel - 1; |
|
727 |
/* store the VLC & sign at once */ |
||
728 |
63333400 |
put_bits(&s->pb, table_vlc[code][1] + 1, |
|
729 |
63333400 |
(table_vlc[code][0] << 1) + sign); |
|
730 |
} else { |
||
731 |
/* escape seems to be pretty rare <5% so I do not optimize it */ |
||
732 |
2066378 |
put_bits(&s->pb, table_vlc[111][1], table_vlc[111][0]); |
|
733 |
/* escape: only clip in this case */ |
||
734 |
2066378 |
put_bits(&s->pb, 6, run); |
|
735 |
✓✓ | 2066378 |
if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) { |
736 |
✓✗ | 82631 |
if (alevel < 128) { |
737 |
82631 |
put_sbits(&s->pb, 8, level); |
|
738 |
} else { |
||
739 |
if (level < 0) |
||
740 |
put_bits(&s->pb, 16, 0x8001 + level + 255); |
||
741 |
else |
||
742 |
put_sbits(&s->pb, 16, level); |
||
743 |
} |
||
744 |
} else { |
||
745 |
1983747 |
put_sbits(&s->pb, 12, level); |
|
746 |
} |
||
747 |
} |
||
748 |
65399778 |
last_non_zero = i; |
|
749 |
} |
||
750 |
} |
||
751 |
/* end of block */ |
||
752 |
6384584 |
put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]); |
|
753 |
6384584 |
} |
|
754 |
|||
755 |
1567917 |
static av_always_inline void mpeg1_encode_mb_internal(MpegEncContext *s, |
|
756 |
int16_t block[8][64], |
||
757 |
int motion_x, int motion_y, |
||
758 |
int mb_block_count) |
||
759 |
{ |
||
760 |
int i, cbp; |
||
761 |
1567917 |
const int mb_x = s->mb_x; |
|
762 |
1567917 |
const int mb_y = s->mb_y; |
|
763 |
✓✓✓✓ |
1567917 |
const int first_mb = mb_x == s->resync_mb_x && mb_y == s->resync_mb_y; |
764 |
|||
765 |
/* compute cbp */ |
||
766 |
1567917 |
cbp = 0; |
|
767 |
✓✓ | 12261649 |
for (i = 0; i < mb_block_count; i++) |
768 |
✓✓ | 10693732 |
if (s->block_last_index[i] >= 0) |
769 |
6384584 |
cbp |= 1 << (mb_block_count - 1 - i); |
|
770 |
|||
771 |
✓✓✓✓ ✓✓ |
1567917 |
if (cbp == 0 && !first_mb && s->mv_type == MV_TYPE_16X16 && |
772 |
✓✓ | 245714 |
(mb_x != s->mb_width - 1 || |
773 |
✓✓✓✓ |
7348 |
(mb_y != s->end_mb_y - 1 && s->codec_id == AV_CODEC_ID_MPEG1VIDEO)) && |
774 |
✓✓✓✓ |
238908 |
((s->pict_type == AV_PICTURE_TYPE_P && (motion_x | motion_y) == 0) || |
775 |
✓✓✓✓ |
228671 |
(s->pict_type == AV_PICTURE_TYPE_B && s->mv_dir == s->last_mv_dir && |
776 |
21548 |
(((s->mv_dir & MV_DIR_FORWARD) |
|
777 |
20583 |
? ((s->mv[0][0][0] - s->last_mv[0][0][0]) | |
|
778 |
✓✓✓✓ |
43096 |
(s->mv[0][0][1] - s->last_mv[0][0][1])) : 0) | |
779 |
21548 |
((s->mv_dir & MV_DIR_BACKWARD) |
|
780 |
20991 |
? ((s->mv[1][0][0] - s->last_mv[1][0][0]) | |
|
781 |
✓✓ | 21548 |
(s->mv[1][0][1] - s->last_mv[1][0][1])) : 0)) == 0))) { |
782 |
14116 |
s->mb_skip_run++; |
|
783 |
14116 |
s->qscale -= s->dquant; |
|
784 |
14116 |
s->skip_count++; |
|
785 |
14116 |
s->misc_bits++; |
|
786 |
14116 |
s->last_bits++; |
|
787 |
✓✓ | 14116 |
if (s->pict_type == AV_PICTURE_TYPE_P) { |
788 |
10237 |
s->last_mv[0][0][0] = |
|
789 |
10237 |
s->last_mv[0][0][1] = |
|
790 |
10237 |
s->last_mv[0][1][0] = |
|
791 |
10237 |
s->last_mv[0][1][1] = 0; |
|
792 |
} |
||
793 |
} else { |
||
794 |
✓✓ | 1553801 |
if (first_mb) { |
795 |
✗✓ | 316054 |
av_assert0(s->mb_skip_run == 0); |
796 |
316054 |
encode_mb_skip_run(s, s->mb_x); |
|
797 |
} else { |
||
798 |
1237747 |
encode_mb_skip_run(s, s->mb_skip_run); |
|
799 |
} |
||
800 |
|||
801 |
✓✓ | 1553801 |
if (s->pict_type == AV_PICTURE_TYPE_I) { |
802 |
✓✓✓✗ |
377814 |
if (s->dquant && cbp) { |
803 |
/* macroblock_type: macroblock_quant = 1 */ |
||
804 |
43950 |
put_mb_modes(s, 2, 1, 0, 0); |
|
805 |
43950 |
put_qscale(s); |
|
806 |
} else { |
||
807 |
/* macroblock_type: macroblock_quant = 0 */ |
||
808 |
333864 |
put_mb_modes(s, 1, 1, 0, 0); |
|
809 |
333864 |
s->qscale -= s->dquant; |
|
810 |
} |
||
811 |
377814 |
s->misc_bits += get_bits_diff(s); |
|
812 |
377814 |
s->i_count++; |
|
813 |
✓✓ | 1175987 |
} else if (s->mb_intra) { |
814 |
✓✓✓✗ |
50915 |
if (s->dquant && cbp) { |
815 |
11248 |
put_mb_modes(s, 6, 0x01, 0, 0); |
|
816 |
11248 |
put_qscale(s); |
|
817 |
} else { |
||
818 |
39667 |
put_mb_modes(s, 5, 0x03, 0, 0); |
|
819 |
39667 |
s->qscale -= s->dquant; |
|
820 |
} |
||
821 |
50915 |
s->misc_bits += get_bits_diff(s); |
|
822 |
50915 |
s->i_count++; |
|
823 |
50915 |
memset(s->last_mv, 0, sizeof(s->last_mv)); |
|
824 |
✓✓ | 1125072 |
} else if (s->pict_type == AV_PICTURE_TYPE_P) { |
825 |
✓✓ | 543728 |
if (s->mv_type == MV_TYPE_16X16) { |
826 |
✓✓ | 520775 |
if (cbp != 0) { |
827 |
✓✓ | 455483 |
if ((motion_x | motion_y) == 0) { |
828 |
✓✓ | 43428 |
if (s->dquant) { |
829 |
/* macroblock_pattern & quant */ |
||
830 |
4208 |
put_mb_modes(s, 5, 1, 0, 0); |
|
831 |
4208 |
put_qscale(s); |
|
832 |
} else { |
||
833 |
/* macroblock_pattern only */ |
||
834 |
39220 |
put_mb_modes(s, 2, 1, 0, 0); |
|
835 |
} |
||
836 |
43428 |
s->misc_bits += get_bits_diff(s); |
|
837 |
} else { |
||
838 |
✓✓ | 412055 |
if (s->dquant) { |
839 |
70756 |
put_mb_modes(s, 5, 2, 1, 0); /* motion + cbp */ |
|
840 |
70756 |
put_qscale(s); |
|
841 |
} else { |
||
842 |
341299 |
put_mb_modes(s, 1, 1, 1, 0); /* motion + cbp */ |
|
843 |
} |
||
844 |
412055 |
s->misc_bits += get_bits_diff(s); |
|
845 |
// RAL: f_code parameter added |
||
846 |
412055 |
mpeg1_encode_motion(s, |
|
847 |
412055 |
motion_x - s->last_mv[0][0][0], |
|
848 |
s->f_code); |
||
849 |
// RAL: f_code parameter added |
||
850 |
412055 |
mpeg1_encode_motion(s, |
|
851 |
412055 |
motion_y - s->last_mv[0][0][1], |
|
852 |
s->f_code); |
||
853 |
412055 |
s->mv_bits += get_bits_diff(s); |
|
854 |
} |
||
855 |
} else { |
||
856 |
65292 |
put_bits(&s->pb, 3, 1); /* motion only */ |
|
857 |
✓✓ | 65292 |
if (!s->frame_pred_frame_dct) |
858 |
16441 |
put_bits(&s->pb, 2, 2); /* motion_type: frame */ |
|
859 |
65292 |
s->misc_bits += get_bits_diff(s); |
|
860 |
// RAL: f_code parameter added |
||
861 |
65292 |
mpeg1_encode_motion(s, |
|
862 |
65292 |
motion_x - s->last_mv[0][0][0], |
|
863 |
s->f_code); |
||
864 |
// RAL: f_code parameter added |
||
865 |
65292 |
mpeg1_encode_motion(s, |
|
866 |
65292 |
motion_y - s->last_mv[0][0][1], |
|
867 |
s->f_code); |
||
868 |
65292 |
s->qscale -= s->dquant; |
|
869 |
65292 |
s->mv_bits += get_bits_diff(s); |
|
870 |
} |
||
871 |
520775 |
s->last_mv[0][1][0] = s->last_mv[0][0][0] = motion_x; |
|
872 |
520775 |
s->last_mv[0][1][1] = s->last_mv[0][0][1] = motion_y; |
|
873 |
} else { |
||
874 |
av_assert2(!s->frame_pred_frame_dct && s->mv_type == MV_TYPE_FIELD); |
||
875 |
|||
876 |
✓✓ | 22953 |
if (cbp) { |
877 |
✗✓ | 21459 |
if (s->dquant) { |
878 |
put_mb_modes(s, 5, 2, 1, 1); /* motion + cbp */ |
||
879 |
put_qscale(s); |
||
880 |
} else { |
||
881 |
21459 |
put_mb_modes(s, 1, 1, 1, 1); /* motion + cbp */ |
|
882 |
} |
||
883 |
} else { |
||
884 |
1494 |
put_bits(&s->pb, 3, 1); /* motion only */ |
|
885 |
1494 |
put_bits(&s->pb, 2, 1); /* motion_type: field */ |
|
886 |
1494 |
s->qscale -= s->dquant; |
|
887 |
} |
||
888 |
22953 |
s->misc_bits += get_bits_diff(s); |
|
889 |
✓✓ | 68859 |
for (i = 0; i < 2; i++) { |
890 |
45906 |
put_bits(&s->pb, 1, s->field_select[0][i]); |
|
891 |
45906 |
mpeg1_encode_motion(s, |
|
892 |
45906 |
s->mv[0][i][0] - s->last_mv[0][i][0], |
|
893 |
s->f_code); |
||
894 |
45906 |
mpeg1_encode_motion(s, |
|
895 |
45906 |
s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1), |
|
896 |
s->f_code); |
||
897 |
45906 |
s->last_mv[0][i][0] = s->mv[0][i][0]; |
|
898 |
45906 |
s->last_mv[0][i][1] = 2 * s->mv[0][i][1]; |
|
899 |
} |
||
900 |
22953 |
s->mv_bits += get_bits_diff(s); |
|
901 |
} |
||
902 |
✓✓ | 543728 |
if (cbp) { |
903 |
✓✓ | 476942 |
if (s->chroma_y_shift) { |
904 |
401019 |
put_bits(&s->pb, |
|
905 |
401019 |
ff_mpeg12_mbPatTable[cbp][1], |
|
906 |
401019 |
ff_mpeg12_mbPatTable[cbp][0]); |
|
907 |
} else { |
||
908 |
75923 |
put_bits(&s->pb, |
|
909 |
75923 |
ff_mpeg12_mbPatTable[cbp >> 2][1], |
|
910 |
75923 |
ff_mpeg12_mbPatTable[cbp >> 2][0]); |
|
911 |
75923 |
put_sbits(&s->pb, 2, cbp); |
|
912 |
} |
||
913 |
} |
||
914 |
543728 |
s->f_count++; |
|
915 |
} else { |
||
916 |
✓✓ | 581344 |
if (s->mv_type == MV_TYPE_16X16) { |
917 |
✓✓ | 486295 |
if (cbp) { // With coded bloc pattern |
918 |
✓✓ | 314569 |
if (s->dquant) { |
919 |
✓✓ | 55606 |
if (s->mv_dir == MV_DIR_FORWARD) |
920 |
12773 |
put_mb_modes(s, 6, 3, 1, 0); |
|
921 |
else |
||
922 |
42833 |
put_mb_modes(s, 8 - s->mv_dir, 2, 1, 0); |
|
923 |
55606 |
put_qscale(s); |
|
924 |
} else { |
||
925 |
258963 |
put_mb_modes(s, 5 - s->mv_dir, 3, 1, 0); |
|
926 |
} |
||
927 |
} else { // No coded bloc pattern |
||
928 |
171726 |
put_bits(&s->pb, 5 - s->mv_dir, 2); |
|
929 |
✓✓ | 171726 |
if (!s->frame_pred_frame_dct) |
930 |
78149 |
put_bits(&s->pb, 2, 2); /* motion_type: frame */ |
|
931 |
171726 |
s->qscale -= s->dquant; |
|
932 |
} |
||
933 |
486295 |
s->misc_bits += get_bits_diff(s); |
|
934 |
✓✓ | 486295 |
if (s->mv_dir & MV_DIR_FORWARD) { |
935 |
347991 |
mpeg1_encode_motion(s, |
|
936 |
347991 |
s->mv[0][0][0] - s->last_mv[0][0][0], |
|
937 |
s->f_code); |
||
938 |
347991 |
mpeg1_encode_motion(s, |
|
939 |
347991 |
s->mv[0][0][1] - s->last_mv[0][0][1], |
|
940 |
s->f_code); |
||
941 |
347991 |
s->last_mv[0][0][0] = |
|
942 |
347991 |
s->last_mv[0][1][0] = s->mv[0][0][0]; |
|
943 |
347991 |
s->last_mv[0][0][1] = |
|
944 |
347991 |
s->last_mv[0][1][1] = s->mv[0][0][1]; |
|
945 |
347991 |
s->f_count++; |
|
946 |
} |
||
947 |
✓✓ | 486295 |
if (s->mv_dir & MV_DIR_BACKWARD) { |
948 |
366304 |
mpeg1_encode_motion(s, |
|
949 |
366304 |
s->mv[1][0][0] - s->last_mv[1][0][0], |
|
950 |
s->b_code); |
||
951 |
366304 |
mpeg1_encode_motion(s, |
|
952 |
366304 |
s->mv[1][0][1] - s->last_mv[1][0][1], |
|
953 |
s->b_code); |
||
954 |
366304 |
s->last_mv[1][0][0] = |
|
955 |
366304 |
s->last_mv[1][1][0] = s->mv[1][0][0]; |
|
956 |
366304 |
s->last_mv[1][0][1] = |
|
957 |
366304 |
s->last_mv[1][1][1] = s->mv[1][0][1]; |
|
958 |
366304 |
s->b_count++; |
|
959 |
} |
||
960 |
} else { |
||
961 |
av_assert2(s->mv_type == MV_TYPE_FIELD); |
||
962 |
av_assert2(!s->frame_pred_frame_dct); |
||
963 |
✓✓ | 95049 |
if (cbp) { // With coded bloc pattern |
964 |
✗✓ | 74532 |
if (s->dquant) { |
965 |
if (s->mv_dir == MV_DIR_FORWARD) |
||
966 |
put_mb_modes(s, 6, 3, 1, 1); |
||
967 |
else |
||
968 |
put_mb_modes(s, 8 - s->mv_dir, 2, 1, 1); |
||
969 |
put_qscale(s); |
||
970 |
} else { |
||
971 |
74532 |
put_mb_modes(s, 5 - s->mv_dir, 3, 1, 1); |
|
972 |
} |
||
973 |
} else { // No coded bloc pattern |
||
974 |
20517 |
put_bits(&s->pb, 5 - s->mv_dir, 2); |
|
975 |
20517 |
put_bits(&s->pb, 2, 1); /* motion_type: field */ |
|
976 |
20517 |
s->qscale -= s->dquant; |
|
977 |
} |
||
978 |
95049 |
s->misc_bits += get_bits_diff(s); |
|
979 |
✓✓ | 95049 |
if (s->mv_dir & MV_DIR_FORWARD) { |
980 |
✓✓ | 182619 |
for (i = 0; i < 2; i++) { |
981 |
121746 |
put_bits(&s->pb, 1, s->field_select[0][i]); |
|
982 |
121746 |
mpeg1_encode_motion(s, |
|
983 |
121746 |
s->mv[0][i][0] - s->last_mv[0][i][0], |
|
984 |
s->f_code); |
||
985 |
121746 |
mpeg1_encode_motion(s, |
|
986 |
121746 |
s->mv[0][i][1] - (s->last_mv[0][i][1] >> 1), |
|
987 |
s->f_code); |
||
988 |
121746 |
s->last_mv[0][i][0] = s->mv[0][i][0]; |
|
989 |
121746 |
s->last_mv[0][i][1] = s->mv[0][i][1] * 2; |
|
990 |
} |
||
991 |
60873 |
s->f_count++; |
|
992 |
} |
||
993 |
✓✓ | 95049 |
if (s->mv_dir & MV_DIR_BACKWARD) { |
994 |
✓✓ | 183525 |
for (i = 0; i < 2; i++) { |
995 |
122350 |
put_bits(&s->pb, 1, s->field_select[1][i]); |
|
996 |
122350 |
mpeg1_encode_motion(s, |
|
997 |
122350 |
s->mv[1][i][0] - s->last_mv[1][i][0], |
|
998 |
s->b_code); |
||
999 |
122350 |
mpeg1_encode_motion(s, |
|
1000 |
122350 |
s->mv[1][i][1] - (s->last_mv[1][i][1] >> 1), |
|
1001 |
s->b_code); |
||
1002 |
122350 |
s->last_mv[1][i][0] = s->mv[1][i][0]; |
|
1003 |
122350 |
s->last_mv[1][i][1] = s->mv[1][i][1] * 2; |
|
1004 |
} |
||
1005 |
61175 |
s->b_count++; |
|
1006 |
} |
||
1007 |
} |
||
1008 |
581344 |
s->mv_bits += get_bits_diff(s); |
|
1009 |
✓✓ | 581344 |
if (cbp) { |
1010 |
✓✓ | 389101 |
if (s->chroma_y_shift) { |
1011 |
206508 |
put_bits(&s->pb, |
|
1012 |
206508 |
ff_mpeg12_mbPatTable[cbp][1], |
|
1013 |
206508 |
ff_mpeg12_mbPatTable[cbp][0]); |
|
1014 |
} else { |
||
1015 |
182593 |
put_bits(&s->pb, |
|
1016 |
182593 |
ff_mpeg12_mbPatTable[cbp >> 2][1], |
|
1017 |
182593 |
ff_mpeg12_mbPatTable[cbp >> 2][0]); |
|
1018 |
182593 |
put_sbits(&s->pb, 2, cbp); |
|
1019 |
} |
||
1020 |
} |
||
1021 |
} |
||
1022 |
✓✓ | 12161611 |
for (i = 0; i < mb_block_count; i++) |
1023 |
✓✓ | 10607810 |
if (cbp & (1 << (mb_block_count - 1 - i))) |
1024 |
6384584 |
mpeg1_encode_block(s, block[i], i); |
|
1025 |
1553801 |
s->mb_skip_run = 0; |
|
1026 |
✓✓ | 1553801 |
if (s->mb_intra) |
1027 |
428729 |
s->i_tex_bits += get_bits_diff(s); |
|
1028 |
else |
||
1029 |
1125072 |
s->p_tex_bits += get_bits_diff(s); |
|
1030 |
} |
||
1031 |
1567917 |
} |
|
1032 |
|||
1033 |
1567917 |
void ff_mpeg1_encode_mb(MpegEncContext *s, int16_t block[8][64], |
|
1034 |
int motion_x, int motion_y) |
||
1035 |
{ |
||
1036 |
✓✓ | 1567917 |
if (s->chroma_format == CHROMA_420) |
1037 |
924802 |
mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 6); |
|
1038 |
else |
||
1039 |
643115 |
mpeg1_encode_mb_internal(s, block, motion_x, motion_y, 8); |
|
1040 |
1567917 |
} |
|
1041 |
|||
1042 |
48 |
static av_cold void mpeg12_encode_init_static(void) |
|
1043 |
{ |
||
1044 |
static uint8_t mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3]; |
||
1045 |
|||
1046 |
48 |
ff_rl_init(&ff_rl_mpeg1, mpeg12_static_rl_table_store[0]); |
|
1047 |
48 |
ff_rl_init(&ff_rl_mpeg2, mpeg12_static_rl_table_store[1]); |
|
1048 |
|||
1049 |
✓✓ | 3120 |
for (int i = 0; i < 64; i++) { |
1050 |
3072 |
mpeg1_max_level[0][i] = ff_rl_mpeg1.max_level[0][i]; |
|
1051 |
3072 |
mpeg1_index_run[0][i] = ff_rl_mpeg1.index_run[0][i]; |
|
1052 |
} |
||
1053 |
|||
1054 |
48 |
ff_mpeg1_init_uni_ac_vlc(&ff_rl_mpeg1, uni_mpeg1_ac_vlc_len); |
|
1055 |
48 |
ff_mpeg1_init_uni_ac_vlc(&ff_rl_mpeg2, uni_mpeg2_ac_vlc_len); |
|
1056 |
|||
1057 |
/* build unified dc encoding tables */ |
||
1058 |
✓✓ | 24576 |
for (int i = -255; i < 256; i++) { |
1059 |
int adiff, index; |
||
1060 |
int bits, code; |
||
1061 |
24528 |
int diff = i; |
|
1062 |
|||
1063 |
24528 |
adiff = FFABS(diff); |
|
1064 |
✓✓ | 24528 |
if (diff < 0) |
1065 |
12240 |
diff--; |
|
1066 |
24528 |
index = av_log2(2 * adiff); |
|
1067 |
|||
1068 |
24528 |
bits = ff_mpeg12_vlc_dc_lum_bits[index] + index; |
|
1069 |
24528 |
code = (ff_mpeg12_vlc_dc_lum_code[index] << index) + |
|
1070 |
24528 |
av_mod_uintp2(diff, index); |
|
1071 |
24528 |
mpeg1_lum_dc_uni[i + 255] = bits + (code << 8); |
|
1072 |
|||
1073 |
24528 |
bits = ff_mpeg12_vlc_dc_chroma_bits[index] + index; |
|
1074 |
24528 |
code = (ff_mpeg12_vlc_dc_chroma_code[index] << index) + |
|
1075 |
24528 |
av_mod_uintp2(diff, index); |
|
1076 |
24528 |
mpeg1_chr_dc_uni[i + 255] = bits + (code << 8); |
|
1077 |
} |
||
1078 |
|||
1079 |
✓✓ | 384 |
for (int f_code = 1; f_code <= MAX_FCODE; f_code++) |
1080 |
✓✓ | 5505696 |
for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) { |
1081 |
int len; |
||
1082 |
|||
1083 |
✓✓ | 5505360 |
if (mv == 0) { |
1084 |
336 |
len = ff_mpeg12_mbMotionVectorTable[0][1]; |
|
1085 |
} else { |
||
1086 |
int val, bit_size, code; |
||
1087 |
|||
1088 |
5505024 |
bit_size = f_code - 1; |
|
1089 |
|||
1090 |
5505024 |
val = mv; |
|
1091 |
✓✓ | 5505024 |
if (val < 0) |
1092 |
2752512 |
val = -val; |
|
1093 |
5505024 |
val--; |
|
1094 |
5505024 |
code = (val >> bit_size) + 1; |
|
1095 |
✓✓ | 5505024 |
if (code < 17) |
1096 |
195072 |
len = ff_mpeg12_mbMotionVectorTable[code][1] + |
|
1097 |
1 + bit_size; |
||
1098 |
else |
||
1099 |
5309952 |
len = ff_mpeg12_mbMotionVectorTable[16][1] + |
|
1100 |
2 + bit_size; |
||
1101 |
} |
||
1102 |
|||
1103 |
5505360 |
mv_penalty[f_code][mv + MAX_DMV] = len; |
|
1104 |
} |
||
1105 |
|||
1106 |
|||
1107 |
✓✓ | 384 |
for (int f_code = MAX_FCODE; f_code > 0; f_code--) |
1108 |
✓✓ | 195408 |
for (int mv = -(8 << f_code); mv < (8 << f_code); mv++) |
1109 |
195072 |
fcode_tab[mv + MAX_MV] = f_code; |
|
1110 |
48 |
} |
|
1111 |
|||
1112 |
48 |
av_cold void ff_mpeg1_encode_init(MpegEncContext *s) |
|
1113 |
{ |
||
1114 |
static AVOnce init_static_once = AV_ONCE_INIT; |
||
1115 |
|||
1116 |
48 |
ff_mpeg12_common_init(s); |
|
1117 |
|||
1118 |
48 |
s->me.mv_penalty = mv_penalty; |
|
1119 |
48 |
s->fcode_tab = fcode_tab; |
|
1120 |
✓✓ | 48 |
if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO) { |
1121 |
11 |
s->min_qcoeff = -255; |
|
1122 |
11 |
s->max_qcoeff = 255; |
|
1123 |
} else { |
||
1124 |
37 |
s->min_qcoeff = -2047; |
|
1125 |
37 |
s->max_qcoeff = 2047; |
|
1126 |
} |
||
1127 |
✓✓ | 48 |
if (s->intra_vlc_format) { |
1128 |
13 |
s->intra_ac_vlc_length = |
|
1129 |
13 |
s->intra_ac_vlc_last_length = uni_mpeg2_ac_vlc_len; |
|
1130 |
} else { |
||
1131 |
35 |
s->intra_ac_vlc_length = |
|
1132 |
35 |
s->intra_ac_vlc_last_length = uni_mpeg1_ac_vlc_len; |
|
1133 |
} |
||
1134 |
48 |
s->inter_ac_vlc_length = |
|
1135 |
48 |
s->inter_ac_vlc_last_length = uni_mpeg1_ac_vlc_len; |
|
1136 |
|||
1137 |
48 |
ff_thread_once(&init_static_once, mpeg12_encode_init_static); |
|
1138 |
48 |
} |
|
1139 |
|||
1140 |
#define OFFSET(x) offsetof(MpegEncContext, x) |
||
1141 |
#define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM |
||
1142 |
#define COMMON_OPTS \ |
||
1143 |
{ "gop_timecode", "MPEG GOP Timecode in hh:mm:ss[:;.]ff format. Overrides timecode_frame_start.", \ |
||
1144 |
OFFSET(tc_opt_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE },\ |
||
1145 |
{ "drop_frame_timecode", "Timecode is in drop frame format.", \ |
||
1146 |
OFFSET(drop_frame_timecode), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \ |
||
1147 |
{ "scan_offset", "Reserve space for SVCD scan offset user data.", \ |
||
1148 |
OFFSET(scan_offset), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, \ |
||
1149 |
{ "timecode_frame_start", "GOP timecode frame start number, in non-drop-frame format", \ |
||
1150 |
OFFSET(timecode_frame_start), AV_OPT_TYPE_INT64, {.i64 = -1 }, -1, INT64_MAX, VE}, \ |
||
1151 |
|||
1152 |
static const AVOption mpeg1_options[] = { |
||
1153 |
COMMON_OPTS |
||
1154 |
FF_MPV_COMMON_OPTS |
||
1155 |
{ NULL }, |
||
1156 |
}; |
||
1157 |
|||
1158 |
static const AVOption mpeg2_options[] = { |
||
1159 |
COMMON_OPTS |
||
1160 |
{ "intra_vlc", "Use MPEG-2 intra VLC table.", |
||
1161 |
OFFSET(intra_vlc_format), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, |
||
1162 |
{ "non_linear_quant", "Use nonlinear quantizer.", OFFSET(q_scale_type), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, |
||
1163 |
{ "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, |
||
1164 |
{ "seq_disp_ext", "Write sequence_display_extension blocks.", OFFSET(seq_disp_ext), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE, "seq_disp_ext" }, |
||
1165 |
{ "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, VE, "seq_disp_ext" }, |
||
1166 |
{ "never", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, "seq_disp_ext" }, |
||
1167 |
{ "always", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, VE, "seq_disp_ext" }, |
||
1168 |
{ "video_format", "Video_format in the sequence_display_extension indicating the source of the video.", OFFSET(video_format), AV_OPT_TYPE_INT, { .i64 = VIDEO_FORMAT_UNSPECIFIED }, 0, 7, VE, "video_format" }, |
||
1169 |
{ "component", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_COMPONENT }, 0, 0, VE, "video_format" }, |
||
1170 |
{ "pal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_PAL }, 0, 0, VE, "video_format" }, |
||
1171 |
{ "ntsc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_NTSC }, 0, 0, VE, "video_format" }, |
||
1172 |
{ "secam", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_SECAM }, 0, 0, VE, "video_format" }, |
||
1173 |
{ "mac", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_MAC }, 0, 0, VE, "video_format" }, |
||
1174 |
{ "unspecified", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_FORMAT_UNSPECIFIED}, 0, 0, VE, "video_format" }, |
||
1175 |
#define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, "avctx.level" |
||
1176 |
{ LEVEL("high", 4) }, |
||
1177 |
{ LEVEL("high1440", 6) }, |
||
1178 |
{ LEVEL("main", 8) }, |
||
1179 |
{ LEVEL("low", 10) }, |
||
1180 |
#undef LEVEL |
||
1181 |
FF_MPV_COMMON_OPTS |
||
1182 |
FF_MPEG2_PROFILE_OPTS |
||
1183 |
{ NULL }, |
||
1184 |
}; |
||
1185 |
|||
1186 |
#define mpeg12_class(x) \ |
||
1187 |
static const AVClass mpeg ## x ## _class = { \ |
||
1188 |
.class_name = "mpeg" # x "video encoder", \ |
||
1189 |
.item_name = av_default_item_name, \ |
||
1190 |
.option = mpeg ## x ## _options, \ |
||
1191 |
.version = LIBAVUTIL_VERSION_INT, \ |
||
1192 |
}; |
||
1193 |
|||
1194 |
mpeg12_class(1) |
||
1195 |
mpeg12_class(2) |
||
1196 |
|||
1197 |
AVCodec ff_mpeg1video_encoder = { |
||
1198 |
.name = "mpeg1video", |
||
1199 |
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"), |
||
1200 |
.type = AVMEDIA_TYPE_VIDEO, |
||
1201 |
.id = AV_CODEC_ID_MPEG1VIDEO, |
||
1202 |
.priv_data_size = sizeof(MpegEncContext), |
||
1203 |
.init = encode_init, |
||
1204 |
.encode2 = ff_mpv_encode_picture, |
||
1205 |
.close = ff_mpv_encode_end, |
||
1206 |
.supported_framerates = ff_mpeg12_frame_rate_tab + 1, |
||
1207 |
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, |
||
1208 |
AV_PIX_FMT_NONE }, |
||
1209 |
.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS, |
||
1210 |
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP, |
||
1211 |
.priv_class = &mpeg1_class, |
||
1212 |
}; |
||
1213 |
|||
1214 |
AVCodec ff_mpeg2video_encoder = { |
||
1215 |
.name = "mpeg2video", |
||
1216 |
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"), |
||
1217 |
.type = AVMEDIA_TYPE_VIDEO, |
||
1218 |
.id = AV_CODEC_ID_MPEG2VIDEO, |
||
1219 |
.priv_data_size = sizeof(MpegEncContext), |
||
1220 |
.init = encode_init, |
||
1221 |
.encode2 = ff_mpv_encode_picture, |
||
1222 |
.close = ff_mpv_encode_end, |
||
1223 |
.supported_framerates = ff_mpeg2_frame_rate_tab, |
||
1224 |
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, |
||
1225 |
AV_PIX_FMT_YUV422P, |
||
1226 |
AV_PIX_FMT_NONE }, |
||
1227 |
.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS, |
||
1228 |
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP, |
||
1229 |
.priv_class = &mpeg2_class, |
||
1230 |
}; |
||
1231 |
#endif /* CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER */ |
Generated by: GCOVR (Version 4.2) |