Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * H.261 encoder | ||
3 | * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> | ||
4 | * Copyright (c) 2004 Maarten Daniels | ||
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 | * H.261 encoder. | ||
26 | */ | ||
27 | |||
28 | #include "libavutil/attributes.h" | ||
29 | #include "libavutil/avassert.h" | ||
30 | #include "libavutil/thread.h" | ||
31 | #include "avcodec.h" | ||
32 | #include "codec_internal.h" | ||
33 | #include "mpegutils.h" | ||
34 | #include "mpegvideo.h" | ||
35 | #include "h261.h" | ||
36 | #include "h261enc.h" | ||
37 | #include "mpegvideodata.h" | ||
38 | #include "mpegvideoenc.h" | ||
39 | |||
40 | static uint8_t uni_h261_rl_len [64*64*2*2]; | ||
41 | #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) | ||
42 | |||
43 | typedef struct H261EncContext { | ||
44 | MpegEncContext s; | ||
45 | |||
46 | H261Context common; | ||
47 | |||
48 | int gob_number; | ||
49 | enum { | ||
50 | H261_QCIF = 0, | ||
51 | H261_CIF = 1, | ||
52 | } format; | ||
53 | } H261EncContext; | ||
54 | |||
55 | 300 | void ff_h261_encode_picture_header(MpegEncContext *s) | |
56 | { | ||
57 | 300 | H261EncContext *const h = (H261EncContext *)s; | |
58 | int temp_ref; | ||
59 | |||
60 | 300 | align_put_bits(&s->pb); | |
61 | |||
62 | /* Update the pointer to last GOB */ | ||
63 | 300 | s->ptr_lastgob = put_bits_ptr(&s->pb); | |
64 | |||
65 | 300 | put_bits(&s->pb, 20, 0x10); /* PSC */ | |
66 | |||
67 | 300 | temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num / | |
68 | 300 | (1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp | |
69 | 300 | put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */ | |
70 | |||
71 | 300 | put_bits(&s->pb, 1, 0); /* split screen off */ | |
72 | 300 | put_bits(&s->pb, 1, 0); /* camera off */ | |
73 | 300 | put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */ | |
74 | |||
75 | 300 | put_bits(&s->pb, 1, h->format); /* 0 == QCIF, 1 == CIF */ | |
76 | |||
77 | 300 | put_bits(&s->pb, 1, 1); /* still image mode */ | |
78 | 300 | put_bits(&s->pb, 1, 1); /* reserved */ | |
79 | |||
80 | 300 | put_bits(&s->pb, 1, 0); /* no PEI */ | |
81 | 300 | h->gob_number = h->format - 1; | |
82 | 300 | s->mb_skip_run = 0; | |
83 | 300 | } | |
84 | |||
85 | /** | ||
86 | * Encode a group of blocks header. | ||
87 | */ | ||
88 | 3600 | static void h261_encode_gob_header(MpegEncContext *s, int mb_line) | |
89 | { | ||
90 | 3600 | H261EncContext *const h = (H261EncContext *)s; | |
91 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3600 times.
|
3600 | if (h->format == H261_QCIF) { |
92 | ✗ | h->gob_number += 2; // QCIF | |
93 | } else { | ||
94 | 3600 | h->gob_number++; // CIF | |
95 | } | ||
96 | 3600 | put_bits(&s->pb, 16, 1); /* GBSC */ | |
97 | 3600 | put_bits(&s->pb, 4, h->gob_number); /* GN */ | |
98 | 3600 | put_bits(&s->pb, 5, s->qscale); /* GQUANT */ | |
99 | 3600 | put_bits(&s->pb, 1, 0); /* no GEI */ | |
100 | 3600 | s->mb_skip_run = 0; | |
101 | 3600 | s->last_mv[0][0][0] = 0; | |
102 | 3600 | s->last_mv[0][0][1] = 0; | |
103 | 3600 | } | |
104 | |||
105 | 118800 | void ff_h261_reorder_mb_index(MpegEncContext *s) | |
106 | { | ||
107 | 118800 | const H261EncContext *const h = (H261EncContext*)s; | |
108 | 118800 | int index = s->mb_x + s->mb_y * s->mb_width; | |
109 | |||
110 |
2/2✓ Branch 0 taken 10800 times.
✓ Branch 1 taken 108000 times.
|
118800 | if (index % 11 == 0) { |
111 |
2/2✓ Branch 0 taken 3600 times.
✓ Branch 1 taken 7200 times.
|
10800 | if (index % 33 == 0) |
112 | 3600 | h261_encode_gob_header(s, 0); | |
113 | 10800 | s->last_mv[0][0][0] = 0; | |
114 | 10800 | s->last_mv[0][0][1] = 0; | |
115 | } | ||
116 | |||
117 | /* for CIF the GOB's are fragmented in the middle of a scanline | ||
118 | * that's why we need to adjust the x and y index of the macroblocks */ | ||
119 |
1/2✓ Branch 0 taken 118800 times.
✗ Branch 1 not taken.
|
118800 | if (h->format == H261_CIF) { |
120 | 118800 | s->mb_x = index % 11; | |
121 | 118800 | index /= 11; | |
122 | 118800 | s->mb_y = index % 3; | |
123 | 118800 | index /= 3; | |
124 | 118800 | s->mb_x += 11 * (index % 2); | |
125 | 118800 | index /= 2; | |
126 | 118800 | s->mb_y += 3 * index; | |
127 | |||
128 | 118800 | ff_init_block_index(s); | |
129 | 118800 | ff_update_block_index(s, 8, 0, 1); | |
130 | } | ||
131 | 118800 | } | |
132 | |||
133 | 201048 | static void h261_encode_motion(PutBitContext *pb, int val) | |
134 | { | ||
135 | int sign, code; | ||
136 |
2/2✓ Branch 0 taken 113914 times.
✓ Branch 1 taken 87134 times.
|
201048 | if (val == 0) { |
137 | 113914 | code = 0; | |
138 | 113914 | put_bits(pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]); | |
139 | } else { | ||
140 |
2/2✓ Branch 0 taken 45 times.
✓ Branch 1 taken 87089 times.
|
87134 | if (val > 15) |
141 | 45 | val -= 32; | |
142 |
2/2✓ Branch 0 taken 35 times.
✓ Branch 1 taken 87099 times.
|
87134 | if (val < -16) |
143 | 35 | val += 32; | |
144 | 87134 | sign = val < 0; | |
145 |
2/2✓ Branch 0 taken 47447 times.
✓ Branch 1 taken 39687 times.
|
87134 | code = sign ? -val : val; |
146 | 87134 | put_bits(pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]); | |
147 | 87134 | put_bits(pb, 1, sign); | |
148 | } | ||
149 | 201048 | } | |
150 | |||
151 | 104856 | static inline int get_cbp(MpegEncContext *s, int16_t block[6][64]) | |
152 | { | ||
153 | int i, cbp; | ||
154 | 104856 | cbp = 0; | |
155 |
2/2✓ Branch 0 taken 629136 times.
✓ Branch 1 taken 104856 times.
|
733992 | for (i = 0; i < 6; i++) |
156 |
2/2✓ Branch 0 taken 261040 times.
✓ Branch 1 taken 368096 times.
|
629136 | if (s->block_last_index[i] >= 0) |
157 | 261040 | cbp |= 1 << (5 - i); | |
158 | 104856 | return cbp; | |
159 | } | ||
160 | |||
161 | /** | ||
162 | * Encode an 8x8 block. | ||
163 | * @param block the 8x8 block | ||
164 | * @param n block index (0-3 are luma, 4-5 are chroma) | ||
165 | */ | ||
166 | 796752 | static void h261_encode_block(H261EncContext *h, int16_t *block, int n) | |
167 | { | ||
168 | 796752 | MpegEncContext *const s = &h->s; | |
169 | int level, run, i, j, last_index, last_non_zero, sign, slevel, code; | ||
170 | RLTable *rl; | ||
171 | |||
172 | 796752 | rl = &ff_h261_rl_tcoeff; | |
173 |
2/2✓ Branch 0 taken 172932 times.
✓ Branch 1 taken 623820 times.
|
796752 | if (s->mb_intra) { |
174 | /* DC coef */ | ||
175 | 172932 | level = block[0]; | |
176 | /* 255 cannot be represented, so we clamp */ | ||
177 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 172932 times.
|
172932 | if (level > 254) { |
178 | ✗ | level = 254; | |
179 | ✗ | block[0] = 254; | |
180 | } | ||
181 | /* 0 cannot be represented also */ | ||
182 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 172932 times.
|
172932 | else if (level < 1) { |
183 | ✗ | level = 1; | |
184 | ✗ | block[0] = 1; | |
185 | } | ||
186 |
2/2✓ Branch 0 taken 2093 times.
✓ Branch 1 taken 170839 times.
|
172932 | if (level == 128) |
187 | 2093 | put_bits(&s->pb, 8, 0xff); | |
188 | else | ||
189 | 170839 | put_bits(&s->pb, 8, level); | |
190 | 172932 | i = 1; | |
191 |
4/4✓ Branch 0 taken 563387 times.
✓ Branch 1 taken 60433 times.
✓ Branch 2 taken 60856 times.
✓ Branch 3 taken 502531 times.
|
623820 | } else if ((block[0] == 1 || block[0] == -1) && |
192 |
2/2✓ Branch 0 taken 85981 times.
✓ Branch 1 taken 35308 times.
|
121289 | (s->block_last_index[n] > -1)) { |
193 | // special case | ||
194 |
2/2✓ Branch 0 taken 42754 times.
✓ Branch 1 taken 43227 times.
|
85981 | put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3); |
195 | 85981 | i = 1; | |
196 | } else { | ||
197 | 537839 | i = 0; | |
198 | } | ||
199 | |||
200 | /* AC coefs */ | ||
201 | 796752 | last_index = s->block_last_index[n]; | |
202 | 796752 | last_non_zero = i - 1; | |
203 |
2/2✓ Branch 0 taken 9349317 times.
✓ Branch 1 taken 796752 times.
|
10146069 | for (; i <= last_index; i++) { |
204 | 9349317 | j = s->intra_scantable.permutated[i]; | |
205 | 9349317 | level = block[j]; | |
206 |
2/2✓ Branch 0 taken 2765550 times.
✓ Branch 1 taken 6583767 times.
|
9349317 | if (level) { |
207 | 2765550 | run = i - last_non_zero - 1; | |
208 | 2765550 | sign = 0; | |
209 | 2765550 | slevel = level; | |
210 |
2/2✓ Branch 0 taken 1382173 times.
✓ Branch 1 taken 1383377 times.
|
2765550 | if (level < 0) { |
211 | 1382173 | sign = 1; | |
212 | 1382173 | level = -level; | |
213 | } | ||
214 | 2765550 | code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/, | |
215 | run, level); | ||
216 |
4/4✓ Branch 0 taken 1461799 times.
✓ Branch 1 taken 1303751 times.
✓ Branch 2 taken 1458226 times.
✓ Branch 3 taken 3573 times.
|
2765550 | if (run == 0 && level < 16) |
217 | 1458226 | code += 1; | |
218 | 2765550 | put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
219 |
2/2✓ Branch 0 taken 72326 times.
✓ Branch 1 taken 2693224 times.
|
2765550 | if (code == rl->n) { |
220 | 72326 | put_bits(&s->pb, 6, run); | |
221 | av_assert1(slevel != 0); | ||
222 | av_assert1(level <= 127); | ||
223 | 72326 | put_sbits(&s->pb, 8, slevel); | |
224 | } else { | ||
225 | 2693224 | put_bits(&s->pb, 1, sign); | |
226 | } | ||
227 | 2765550 | last_non_zero = i; | |
228 | } | ||
229 | } | ||
230 |
2/2✓ Branch 0 taken 433972 times.
✓ Branch 1 taken 362780 times.
|
796752 | if (last_index > -1) |
231 | 433972 | put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB | |
232 | 796752 | } | |
233 | |||
234 | 133678 | void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], | |
235 | int motion_x, int motion_y) | ||
236 | { | ||
237 | /* The following is only allowed because this encoder | ||
238 | * does not use slice threading. */ | ||
239 | 133678 | H261EncContext *const h = (H261EncContext *)s; | |
240 | 133678 | H261Context *const com = &h->common; | |
241 | int mvd, mv_diff_x, mv_diff_y, i, cbp; | ||
242 | 133678 | cbp = 63; // avoid warning | |
243 | 133678 | mvd = 0; | |
244 | |||
245 | 133678 | com->mtype = 0; | |
246 | |||
247 |
2/2✓ Branch 0 taken 104856 times.
✓ Branch 1 taken 28822 times.
|
133678 | if (!s->mb_intra) { |
248 | /* compute cbp */ | ||
249 | 104856 | cbp = get_cbp(s, block); | |
250 | |||
251 | /* mvd indicates if this block is motion compensated */ | ||
252 | 104856 | mvd = motion_x | motion_y; | |
253 | |||
254 |
2/2✓ Branch 0 taken 886 times.
✓ Branch 1 taken 103970 times.
|
104856 | if ((cbp | mvd) == 0) { |
255 | /* skip macroblock */ | ||
256 | 886 | s->skip_count++; | |
257 | 886 | s->mb_skip_run++; | |
258 | 886 | s->last_mv[0][0][0] = 0; | |
259 | 886 | s->last_mv[0][0][1] = 0; | |
260 | 886 | s->qscale -= s->dquant; | |
261 | 886 | return; | |
262 | } | ||
263 | } | ||
264 | |||
265 | /* MB is not skipped, encode MBA */ | ||
266 | 132792 | put_bits(&s->pb, | |
267 | 132792 | ff_h261_mba_bits[s->mb_skip_run], | |
268 | 132792 | ff_h261_mba_code[s->mb_skip_run]); | |
269 | 132792 | s->mb_skip_run = 0; | |
270 | |||
271 | /* calculate MTYPE */ | ||
272 |
2/2✓ Branch 0 taken 103970 times.
✓ Branch 1 taken 28822 times.
|
132792 | if (!s->mb_intra) { |
273 | 103970 | com->mtype++; | |
274 | |||
275 |
3/4✓ Branch 0 taken 3446 times.
✓ Branch 1 taken 100524 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3446 times.
|
103970 | if (mvd || s->loop_filter) |
276 | 100524 | com->mtype += 3; | |
277 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 103970 times.
|
103970 | if (s->loop_filter) |
278 | ✗ | com->mtype += 3; | |
279 |
2/2✓ Branch 0 taken 84380 times.
✓ Branch 1 taken 19590 times.
|
103970 | if (cbp) |
280 | 84380 | com->mtype++; | |
281 | av_assert1(com->mtype > 1); | ||
282 | } | ||
283 | |||
284 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 132792 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
132792 | if (s->dquant && cbp) { |
285 | ✗ | com->mtype++; | |
286 | } else | ||
287 | 132792 | s->qscale -= s->dquant; | |
288 | |||
289 | 132792 | put_bits(&s->pb, | |
290 | 132792 | ff_h261_mtype_bits[com->mtype], | |
291 | 132792 | ff_h261_mtype_code[com->mtype]); | |
292 | |||
293 | 132792 | com->mtype = ff_h261_mtype_map[com->mtype]; | |
294 | |||
295 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 132792 times.
|
132792 | if (IS_QUANT(com->mtype)) { |
296 | ✗ | ff_set_qscale(s, s->qscale + s->dquant); | |
297 | ✗ | put_bits(&s->pb, 5, s->qscale); | |
298 | } | ||
299 | |||
300 |
2/2✓ Branch 0 taken 100524 times.
✓ Branch 1 taken 32268 times.
|
132792 | if (IS_16X16(com->mtype)) { |
301 | 100524 | mv_diff_x = (motion_x >> 1) - s->last_mv[0][0][0]; | |
302 | 100524 | mv_diff_y = (motion_y >> 1) - s->last_mv[0][0][1]; | |
303 | 100524 | s->last_mv[0][0][0] = (motion_x >> 1); | |
304 | 100524 | s->last_mv[0][0][1] = (motion_y >> 1); | |
305 | 100524 | h261_encode_motion(&s->pb, mv_diff_x); | |
306 | 100524 | h261_encode_motion(&s->pb, mv_diff_y); | |
307 | } | ||
308 | |||
309 |
2/2✓ Branch 0 taken 84380 times.
✓ Branch 1 taken 48412 times.
|
132792 | if (HAS_CBP(com->mtype)) { |
310 | av_assert1(cbp > 0); | ||
311 | 84380 | put_bits(&s->pb, | |
312 | 84380 | ff_h261_cbp_tab[cbp - 1][1], | |
313 | 84380 | ff_h261_cbp_tab[cbp - 1][0]); | |
314 | } | ||
315 |
2/2✓ Branch 0 taken 796752 times.
✓ Branch 1 taken 132792 times.
|
929544 | for (i = 0; i < 6; i++) |
316 | /* encode each block */ | ||
317 | 796752 | h261_encode_block(h, block[i], i); | |
318 | |||
319 |
2/2✓ Branch 0 taken 32268 times.
✓ Branch 1 taken 100524 times.
|
132792 | if (!IS_16X16(com->mtype)) { |
320 | 32268 | s->last_mv[0][0][0] = 0; | |
321 | 32268 | s->last_mv[0][0][1] = 0; | |
322 | } | ||
323 | } | ||
324 | |||
325 | 6 | static av_cold void init_uni_h261_rl_tab(const RLTable *rl, uint8_t *len_tab) | |
326 | { | ||
327 | int slevel, run, last; | ||
328 | |||
329 | av_assert0(MAX_LEVEL >= 64); | ||
330 | av_assert0(MAX_RUN >= 63); | ||
331 | |||
332 |
2/2✓ Branch 0 taken 768 times.
✓ Branch 1 taken 6 times.
|
774 | for(slevel=-64; slevel<64; slevel++){ |
333 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 762 times.
|
768 | if(slevel==0) continue; |
334 |
2/2✓ Branch 0 taken 48768 times.
✓ Branch 1 taken 762 times.
|
49530 | for(run=0; run<64; run++){ |
335 |
2/2✓ Branch 0 taken 97536 times.
✓ Branch 1 taken 48768 times.
|
146304 | for(last=0; last<=1; last++){ |
336 | 97536 | const int index= UNI_ENC_INDEX(last, run, slevel+64); | |
337 | 97536 | int level= slevel < 0 ? -slevel : slevel; | |
338 | int len, code; | ||
339 | |||
340 | 97536 | len_tab[index]= 100; | |
341 | |||
342 | /* ESC0 */ | ||
343 | 97536 | code= get_rl_index(rl, 0, run, level); | |
344 | 97536 | len= rl->table_vlc[code][1] + 1; | |
345 |
2/2✓ Branch 0 taken 48768 times.
✓ Branch 1 taken 48768 times.
|
97536 | if(last) |
346 | 48768 | len += 2; | |
347 | |||
348 |
3/4✓ Branch 0 taken 1512 times.
✓ Branch 1 taken 96024 times.
✓ Branch 2 taken 1512 times.
✗ Branch 3 not taken.
|
97536 | if(code!=rl->n && len < len_tab[index]){ |
349 | 1512 | len_tab [index]= len; | |
350 | } | ||
351 | /* ESC */ | ||
352 | 97536 | len = rl->table_vlc[rl->n][1]; | |
353 |
2/2✓ Branch 0 taken 48768 times.
✓ Branch 1 taken 48768 times.
|
97536 | if(last) |
354 | 48768 | len += 2; | |
355 | |||
356 |
2/2✓ Branch 0 taken 97344 times.
✓ Branch 1 taken 192 times.
|
97536 | if(len < len_tab[index]){ |
357 | 97344 | len_tab [index]= len; | |
358 | } | ||
359 | } | ||
360 | } | ||
361 | } | ||
362 | 6 | } | |
363 | |||
364 | 6 | static av_cold void h261_encode_init_static(void) | |
365 | { | ||
366 | static uint8_t h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3]; | ||
367 | |||
368 | 6 | ff_rl_init(&ff_h261_rl_tcoeff, h261_rl_table_store); | |
369 | 6 | init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len); | |
370 | 6 | } | |
371 | |||
372 | 6 | av_cold int ff_h261_encode_init(MpegEncContext *s) | |
373 | { | ||
374 | 6 | H261EncContext *const h = (H261EncContext*)s; | |
375 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
376 | |||
377 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
6 | if (s->width == 176 && s->height == 144) { |
378 | ✗ | h->format = H261_QCIF; | |
379 |
2/4✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
6 | } else if (s->width == 352 && s->height == 288) { |
380 | 6 | h->format = H261_CIF; | |
381 | } else { | ||
382 | ✗ | av_log(s->avctx, AV_LOG_ERROR, | |
383 | "The specified picture size of %dx%d is not valid for the " | ||
384 | "H.261 codec.\nValid sizes are 176x144, 352x288\n", | ||
385 | s->width, s->height); | ||
386 | ✗ | return AVERROR(EINVAL); | |
387 | } | ||
388 | 6 | s->private_ctx = &h->common; | |
389 | |||
390 | 6 | s->min_qcoeff = -127; | |
391 | 6 | s->max_qcoeff = 127; | |
392 | 6 | s->y_dc_scale_table = | |
393 | 6 | s->c_dc_scale_table = ff_mpeg1_dc_scale_table; | |
394 | 6 | s->ac_esc_length = 6+6+8; | |
395 | |||
396 | 6 | s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len; | |
397 | 6 | s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64; | |
398 | 6 | ff_thread_once(&init_static_once, h261_encode_init_static); | |
399 | |||
400 | 6 | return 0; | |
401 | } | ||
402 | |||
403 | const FFCodec ff_h261_encoder = { | ||
404 | .p.name = "h261", | ||
405 | CODEC_LONG_NAME("H.261"), | ||
406 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
407 | .p.id = AV_CODEC_ID_H261, | ||
408 | .p.priv_class = &ff_mpv_enc_class, | ||
409 | .priv_data_size = sizeof(H261EncContext), | ||
410 | .init = ff_mpv_encode_init, | ||
411 | FF_CODEC_ENCODE_CB(ff_mpv_encode_picture), | ||
412 | .close = ff_mpv_encode_end, | ||
413 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
414 | .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, | ||
415 | AV_PIX_FMT_NONE }, | ||
416 | .p.capabilities = AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | ||
417 | }; | ||
418 |