1 /*
2 libfame - Fast Assembly MPEG Encoder Library
3 Copyright (C) 2000-2001 Vivien Chappelier
4 Thomas Cougnard
5
6 This library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Library General Public
8 License as published by the Free Software Foundation; either
9 version 2 of the License, or (at your option) any later version.
10
11 This library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Library General Public License for more details.
15
16 You should have received a copy of the GNU Library General Public
17 License along with this library; if not, write to the Free
18 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include "fame.h"
25 #include "fame_malloc.h"
26 #include "fame_syntax.h"
27 #include "fame_bitbuffer.h"
28 #include "fame_syntax_mpeg4.h"
29 #include "table_zigzag_mpeg4.h"
30 #include "table_rlehuff_mpeg4.h"
31 #include "table_dc_mpeg4.h"
32 #include "table_cae.h"
33 #include "table_quant_mpeg4.h"
34 #include "table_cbp_mpeg4.h"
35 #include "table_mv.h"
36 #include "table_clip_mpeg4.h"
37 #if defined(HAS_MMX)
38 #include "ac_mmx.h"
39 #else
40 #include "ac_int.h"
41 #endif
42
43 #define OPENDIVX_COMPATIBILITY /* needed to output OpenDivX readable output */
44
45 /* prediction direction */
46 #define LEFT_PREDICTED 0
47 #define TOP_PREDICTED 1
48
49 /* maximum size of arithmetic coded sequence */
50 #define CAE_SEQUENCE_LENGTH 4096
51 #define CAE_MAX_HEADING 3
52 #define CAE_MAX_MIDDLE 10
53 #define CAE_MAX_TRAILING 2
54 #define CAE_1_2 0x80000000
55 #define CAE_1_4 0x40000000
56
57 /* The header codes */
58 #define MPEG4_SEQUENCE_START_CODE 0x1b0
59 #define MPEG4_SEQUENCE_END_CODE 0x1b1
60 #define MPEG4_VISUAL_OBJ_START_CODE 0x1b5
61 #define MPEG4_VIDEO_OBJ_START_CODE 0x100
62 #define MPEG4_VIDEO_OBJ_LAYER_START_CODE 0x120
63 #define MPEG4_GVOP_START_CODE 0x1b3
64 #define MPEG4_VOP_START_CODE 0x1b6
65 #define MPEG4_SLICE_BASE_CODE 0x100
66 /* Visual Object Type */
67 #define MPEG4_Visual_Object_Type_VideoID 0x01
68 #define MPEG4_Visual_Object_Type_still_textureID 0x02
69 #define MPEG4_Visual_Object_Type_meshID 0x03
70 #define MPEG4_Visual_Object_Type_FBA_ID 0x04
71 #define MPEG4_Visual_Object_Type_3D_meshID 0x05
72 /* Video Object type */
73 #define MPEG4_Video_Object_Type_SimpleObject 0x01
74 /* ... */
75 #define MPEG4_Video_Object_Type_FineGranularityScalable 0x12
76
77 /* Aspect Ratio Info */
78 #define MPEG4_Aspect_Ratio_Info_Square 0x01
79 #define MPEG4_Aspect_Ratio_Info_ExtendedPAR 0x0A
80
81 /* Video Object layer Shape */
82 #define MPEG4_Video_Object_Layer_Shape_Rectangular 0x00
83 #define MPEG4_Video_Object_Layer_Shape_Binary 0x01
84 #define MPEG4_Video_Object_Layer_Shape_BinaryOnly 0x02
85 #define MPEG4_Video_Object_Layer_Shape_Grayscale 0x03
86
87 /* VOP Coding Type */
88 #define MPEG4_I_FRAME 0
89 #define MPEG4_P_FRAME 1
90 #define MPEG4_B_FRAME 2
91
92 /* The fixed values */
93 #define MPEG4_PROFILE_AND_LEVEL 0x01
94 #define MPEG4_IS_VISUAL_OBJ_IDENT 0x00
95 #define MPEG4_VISUAL_OBJ_TYPE 0x01
96 #define MPEG4_VIDEO_SIGNAL_TYPE 0x00
97 #define MPEG4_IS_OBJ_LAYER_IDENT 0x00
98 #define MPEG4_VOL_SHAPE_RECTANGULAR 0x00
99 #define MPEG4_VOL_SHAPE_BINARY_ONLY 0x02
100 #define MPEG4_VOP_TIME_INCR_RES 0x000F /* ?? */
101
102 static void mpeg4_init(fame_syntax_t *syntax,
103 int mb_width,
104 int mb_height,
105 unsigned char **intra_default_matrix,
106 unsigned char **inter_default_matrix,
107 unsigned char *intra_dc_y_scale_table,
108 unsigned char *intra_dc_c_scale_table,
109 fame_mismatch_t *mismatch_type,
110 unsigned int flags);
111 static void mpeg4_close(fame_syntax_t *syntax);
112 static void mpeg4_use(fame_syntax_t *syntax,
113 unsigned char *buffer,
114 int size);
115 static int mpeg4_flush(fame_syntax_t *syntax);
116 static void mpeg4_start_sequence(fame_syntax_t *syntax,
117 int width,
118 int height,
119 int fps_num,
120 int fps_den,
121 int size,
122 int bitrate);
123 static void mpeg4_start_GOP(fame_syntax_t *syntax,
124 int frame);
125 static void mpeg4_start_picture(fame_syntax_t *syntax,
126 char frame_type,
127 int frame_number,
128 fame_box_t *box,
129 int rounding_control,
130 int search_range);
131 static void mpeg4_start_slice(fame_syntax_t *syntax,
132 int vpos,
133 int length,
134 unsigned char qscale);
135 static void mpeg4_end_slice(fame_syntax_t *syntax);
136 static void mpeg4_end_sequence(fame_syntax_t *syntax);
137 static void mpeg4_predict_vector(fame_syntax_t *syntax,
138 int mb_x,
139 int mb_y,
140 int k,
141 fame_motion_vector_t *mv);
142 static void mpeg4_compute_chrominance_vectors(fame_syntax_t *syntax,
143 fame_motion_vector_t *vectors,
144 unsigned char pattern);
145 static int mpeg4_write_intra_mb(fame_syntax_t *syntax,
146 int mb_x,
147 int mb_y,
148 short *blocks[6],
149 unsigned char *bab,
150 unsigned char *bab_map,
151 fame_bab_t bab_type,
152 int dquant,
153 unsigned char pattern);
154 static int mpeg4_write_inter_mb(fame_syntax_t *syntax,
155 int mb_x,
156 int mb_y,
157 short *blocks[6],
158 unsigned char *bab,
159 unsigned char *bab_map,
160 fame_bab_t bab_type,
161 int dquant,
162 unsigned char pattern,
163 fame_motion_vector_t *forward,
164 fame_motion_vector_t *backward,
165 fame_motion_coding_t motion_coding);
166
FAME_CONSTRUCTOR(fame_syntax_mpeg4_t)167 FAME_CONSTRUCTOR(fame_syntax_mpeg4_t)
168 {
169 FAME_OBJECT(this)->name = "MPEG-4 bitstream syntax";
170 FAME_SYNTAX(this)->init = mpeg4_init;
171 FAME_SYNTAX(this)->use = mpeg4_use;
172 FAME_SYNTAX(this)->flush = mpeg4_flush;
173 FAME_SYNTAX(this)->start_sequence = mpeg4_start_sequence;
174 FAME_SYNTAX(this)->start_GOP = mpeg4_start_GOP;
175 FAME_SYNTAX(this)->start_picture = mpeg4_start_picture;
176 FAME_SYNTAX(this)->start_slice = mpeg4_start_slice;
177 FAME_SYNTAX(this)->end_slice = mpeg4_end_slice;
178 FAME_SYNTAX(this)->end_sequence = mpeg4_end_sequence;
179 FAME_SYNTAX(this)->predict_vector = mpeg4_predict_vector;
180 FAME_SYNTAX(this)->compute_chrominance_vectors = mpeg4_compute_chrominance_vectors;
181 FAME_SYNTAX(this)->write_intra_mb = mpeg4_write_intra_mb;
182 FAME_SYNTAX(this)->write_inter_mb = mpeg4_write_inter_mb;
183 FAME_SYNTAX(this)->close = mpeg4_close;
184 return(this);
185 }
186
187 static const int bab_type_intra_context_weight[4] = {
188 1, 3, 9, 27
189 };
190
191 static const int bab_type_intra_vl[81][3] = {
192 { 1, 3, 2 },
193 { 3, 2, 1 },
194 { 2, 3, 1 },
195 { 1, 3, 2 },
196 { 1, 2, 3 },
197 { 1, 2, 3 },
198 { 1, 3, 2 },
199 { 1, 2, 3 },
200 { 2, 3, 1 },
201 { 3, 2, 1 },
202 { 1, 2, 3 },
203 { 1, 2, 3 },
204 { 3, 2, 1 },
205 { 1, 2, 3 },
206 { 2, 1, 3 },
207 { 3, 2, 1 },
208 { 1, 2, 3 },
209 { 1, 2, 3 },
210 { 2, 3, 1 },
211 { 1, 2, 3 },
212 { 3, 2, 1 },
213 { 2, 3, 1 },
214 { 1, 2, 3 },
215 { 3, 2, 1 },
216 { 2, 3, 1 },
217 { 3, 2, 1 },
218 { 3, 2, 1 },
219 { 1, 2, 3 },
220 { 1, 2, 3 },
221 { 1, 2, 3 },
222 { 1, 2, 3 },
223 { 1, 2, 3 },
224 { 1, 2, 3 },
225 { 1, 2, 3 },
226 { 1, 2, 3 },
227 { 3, 2, 1 },
228 { 1, 2, 3 },
229 { 3, 2, 1 },
230 { 3, 2, 1 },
231 { 1, 2, 3 },
232 { 3, 1, 2 },
233 { 3, 2, 1 },
234 { 1, 2, 3 },
235 { 3, 1, 2 },
236 { 3, 2, 1 },
237 { 1, 2, 3 },
238 { 3, 2, 1 },
239 { 2, 3, 1 },
240 { 1, 2, 3 },
241 { 3, 2, 1 },
242 { 2, 3, 1 },
243 { 1, 3, 2 },
244 { 3, 1, 2 },
245 { 2, 3, 1 },
246 { 1, 3, 2 },
247 { 2, 3, 1 },
248 { 2, 3, 1 },
249 { 1, 2, 3 },
250 { 1, 2, 3 },
251 { 1, 2, 3 },
252 { 1, 2, 3 },
253 { 1, 2, 3 },
254 { 2, 3, 1 },
255 { 1, 2, 3 },
256 { 3, 2, 1 },
257 { 3, 2, 1 },
258 { 2, 3, 1 },
259 { 3, 1, 2 },
260 { 3, 1, 2 },
261 { 2, 3, 1 },
262 { 3, 1, 2 },
263 { 3, 2, 1 },
264 { 1, 3, 2 },
265 { 3, 2, 1 },
266 { 2, 3, 1 },
267 { 2, 3, 1 },
268 { 3, 1, 2 },
269 { 3, 2, 1 },
270 { 1, 3, 2 },
271 { 3, 1, 2 },
272 { 3, 2, 1 }
273 };
274
get_min_bit(unsigned int n)275 static int inline get_min_bit(unsigned int n)
276 {
277 unsigned int i=0;
278 while (n) {
279 i++;
280 n>>=1;
281 }
282 return i;
283 }
284
mpeg4_init_vlc_tables(fame_vlc_t * intra,fame_vlc_t * inter)285 static void inline mpeg4_init_vlc_tables(fame_vlc_t *intra, fame_vlc_t *inter)
286 {
287 int z, l;
288 int level, run, last, t;
289
290 for(t = 0; t < 2; t++) {
291 fame_vlc_t *vlc;
292
293 /* level = [-255;255], run = [0;64], last = [0;1] */
294 if(t == 0)
295 vlc = intra;
296 else
297 vlc = inter;
298
299 for(last = 0; last < 2; last++) {
300 char *max_level, *max_run;
301 fame_vlc_t **table;
302
303 if(t == 0) {
304 if(last == 0) {
305 max_level = rlehuff_intra_max_level;
306 max_run = rlehuff_intra_max_run;
307 table = rlehuff_intra_notlast_vlc;
308 } else {
309 max_level = rlehuff_intra_max_level_last;
310 max_run = rlehuff_intra_max_run_last;
311 table = rlehuff_intra_last_vlc;
312 }
313 } else {
314 if(last == 0) {
315 max_level = rlehuff_inter_max_level;
316 max_run = rlehuff_inter_max_run;
317 table = rlehuff_inter_notlast_vlc;
318 } else {
319 max_level = rlehuff_inter_max_level_last;
320 max_run = rlehuff_inter_max_run_last;
321 table = rlehuff_inter_last_vlc;
322 }
323 }
324
325 for(l = -255; l < 256; l++) {
326 for(z = 0; z < 64; z++) {
327
328 level = l;
329 run = z;
330
331 if(abs(level) <= max_level[run] && run <= max_run[abs(level)]) {
332 /* vlc */
333 vlc->code = table[run][level].code;
334 vlc->length = table[run][level].length;
335 } else {
336 /* reduce level */
337 if(level > 0) level -= max_level[run];
338 else level += max_level[run];
339
340 if(abs(level) <= max_level[run] && run <= max_run[abs(level)]) {
341 /* escape + 1 + vlc */
342 vlc->code = (0x06 << table[run][level].length) |
343 table[run][level].code;
344 vlc->length = table[run][level].length + 8;
345 } else {
346 /* restore level */
347 if(level > 0) level += max_level[run];
348 else level -= max_level[run];
349
350 /* reduce run */
351 run -= max_run[abs(level)] + 1;
352
353 if(abs(level) <= max_level[run] && run <= max_run[abs(level)]) {
354 /* escape + 01 + vlc */
355 vlc->code = (0x0e << table[run][level].length) |
356 table[run][level].code;
357 vlc->length = table[run][level].length + 9;
358 } else {
359 /* restore run */
360 run += max_run[abs(level)] + 1;
361 /* escape + 00 + last + run + level */
362 vlc->code = (unsigned long) ((0x1e + last) << 20) |
363 (z << 14) | (1 << 13) | ((l & 0xfff) << 1) | 1;
364 vlc->length = 30;
365 }
366 }
367 }
368 vlc++;
369 }
370 }
371 }
372 }
373 }
374
mpeg4_init_symbol(int * symbol)375 static void inline mpeg4_init_symbol(int *symbol)
376 {
377 int i;
378
379 for(i = 0; i < 2048; i++) {
380 if(i & 1) {
381 if(cae_intra_prob[i >> 1] > 32768)
382 symbol[i] = 65536 - cae_intra_prob[i >> 1]; /* > 0 : LPS */
383 else
384 symbol[i] = -cae_intra_prob[i >> 1]; /* < 0 : MPS */
385 } else {
386 if(cae_intra_prob[i >> 1] > 32768)
387 symbol[i] = -(65536 - cae_intra_prob[i >> 1]); /* < 0 : MPS */
388 else
389 symbol[i] = cae_intra_prob[i >> 1]; /* > 0 : LPS */
390 }
391 }
392 }
393
mpeg4_next_start_code(fame_bitbuffer_t * buffer)394 static void inline mpeg4_next_start_code(fame_bitbuffer_t *buffer)
395 {
396 bitbuffer_write(buffer, 0, 1);
397 if(bitbuffer_padding(buffer) != 0)
398 bitbuffer_write(buffer, ((1 << bitbuffer_padding(buffer)) - 1), bitbuffer_padding(buffer));
399 }
400
401 /* The default intra quantisation table */
mpeg4_init(fame_syntax_t * syntax,int mb_width,int mb_height,unsigned char ** intra_matrix,unsigned char ** inter_matrix,unsigned char * intra_dc_y_scale_table,unsigned char * intra_dc_c_scale_table,fame_mismatch_t * mismatch_type,unsigned int flags)402 static void mpeg4_init(fame_syntax_t *syntax,
403 int mb_width,
404 int mb_height,
405 unsigned char **intra_matrix,
406 unsigned char **inter_matrix,
407 unsigned char *intra_dc_y_scale_table,
408 unsigned char *intra_dc_c_scale_table,
409 fame_mismatch_t *mismatch_type,
410 unsigned int flags)
411 {
412 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
413 int i;
414 int qscale;
415
416 syntax_mpeg4->mb_width = mb_width;
417 syntax_mpeg4->mb_height = mb_height;
418 syntax_mpeg4->motion_pred = (fame_motion_vector_t *)
419 fame_malloc(4*mb_width*mb_height*sizeof(fame_motion_vector_t));
420 syntax_mpeg4->cae_h = (fame_syntax_cae_t *) fame_malloc(sizeof(fame_syntax_cae_t));
421 syntax_mpeg4->cae_v = (fame_syntax_cae_t *) fame_malloc(sizeof(fame_syntax_cae_t));
422 syntax_mpeg4->cae_h->buffer = fame_malloc(CAE_SEQUENCE_LENGTH);
423 syntax_mpeg4->cae_v->buffer = fame_malloc(CAE_SEQUENCE_LENGTH);
424 /* alloc one line of blocks for Y, Cr, Cb vertical AC/DC predictors*/
425 /* 15 coefficients need to be kept (7+7 AC + 1 DC) for each predictor */
426 /* 16 are allocated for alignement. */
427 syntax_mpeg4->y_pred_v[0]=(short int **)fame_malloc(mb_width*sizeof(short int *));
428 syntax_mpeg4->y_pred_v[1]=(short int **)fame_malloc(mb_width*sizeof(short int *));
429 syntax_mpeg4->cr_pred_v = (short int **)fame_malloc(mb_width*sizeof(short int *));
430 syntax_mpeg4->cb_pred_v = (short int **)fame_malloc(mb_width*sizeof(short int *));
431 for(i = 0; i < mb_width; i++) {
432 syntax_mpeg4->y_pred_v[0][i] = (short int *)fame_malloc(16 * sizeof(short int));
433 syntax_mpeg4->y_pred_v[1][i] = (short int *)fame_malloc(16 * sizeof(short int));
434 syntax_mpeg4->cr_pred_v[i] = (short int *)fame_malloc(16 * sizeof(short int));
435 syntax_mpeg4->cb_pred_v[i] = (short int *)fame_malloc(16 * sizeof(short int));
436 }
437 syntax_mpeg4->y_pred_h[0] = (short int *) fame_malloc(16 * sizeof(short int));
438 syntax_mpeg4->y_pred_h[1] = (short int *) fame_malloc(16 * sizeof(short int));
439 syntax_mpeg4->y_pred_h[2] = (short int *) fame_malloc(16 * sizeof(short int));
440 syntax_mpeg4->cr_pred_h[0] = (short int *) fame_malloc(16 * sizeof(short int));
441 syntax_mpeg4->cr_pred_h[1] = (short int *) fame_malloc(16 * sizeof(short int));
442 syntax_mpeg4->cb_pred_h[0] = (short int *) fame_malloc(16 * sizeof(short int));
443 syntax_mpeg4->cb_pred_h[1] = (short int *) fame_malloc(16 * sizeof(short int));
444 syntax_mpeg4->pred[0] = (short int *) fame_malloc(16 * sizeof(short int));
445 syntax_mpeg4->pred[1] = (short int *) fame_malloc(16 * sizeof(short int));
446 syntax_mpeg4->pred[2] = (short int *) fame_malloc(16 * sizeof(short int));
447 syntax_mpeg4->pred[3] = (short int *) fame_malloc(16 * sizeof(short int));
448 syntax_mpeg4->pred[4] = (short int *) fame_malloc(16 * sizeof(short int));
449 syntax_mpeg4->pred[5] = (short int *) fame_malloc(16 * sizeof(short int));
450 syntax_mpeg4->diff[0] = (short int *) fame_malloc(16 * sizeof(short int));
451 syntax_mpeg4->diff[1] = (short int *) fame_malloc(16 * sizeof(short int));
452 syntax_mpeg4->diff[2] = (short int *) fame_malloc(16 * sizeof(short int));
453 syntax_mpeg4->diff[3] = (short int *) fame_malloc(16 * sizeof(short int));
454 syntax_mpeg4->diff[4] = (short int *) fame_malloc(16 * sizeof(short int));
455 syntax_mpeg4->diff[5] = (short int *) fame_malloc(16 * sizeof(short int));
456
457 /* compute default DC predictor values */
458 syntax_mpeg4->pred_default = (short int *) fame_malloc(16 * sizeof(short int));
459 memset(syntax_mpeg4->pred_default, 0, 16 * sizeof(short int));
460 syntax_mpeg4->pred_default[0] = 1024;
461
462 syntax_mpeg4->fps_num = 25;
463 syntax_mpeg4->fps_den = 1;
464
465 /* initialize vlc tables */
466 syntax_mpeg4->intra_table =
467 (fame_vlc_t *) fame_malloc(2*64*511*sizeof(fame_vlc_t));
468 syntax_mpeg4->inter_table =
469 (fame_vlc_t *) fame_malloc(2*64*511*sizeof(fame_vlc_t));
470 mpeg4_init_vlc_tables(syntax_mpeg4->intra_table, syntax_mpeg4->inter_table);
471 /* center vlc tables */
472 syntax_mpeg4->intra_table += 64*255;
473 syntax_mpeg4->inter_table += 64*255;
474
475 /* Initialization of default values */
476 /* Video Object Sequence */
477 syntax_mpeg4->profile_and_level_indication = 0x01;
478
479 /* Visual Object */
480 syntax_mpeg4->is_visual_object_identifier = 0;
481 syntax_mpeg4->visual_object_type = MPEG4_Visual_Object_Type_VideoID ;
482 syntax_mpeg4->visual_object_verid = 1;
483 syntax_mpeg4->visual_object_priority = 1;
484 syntax_mpeg4->visual_object_type = 1; /* video ID */
485
486 /* Video Signal Type */
487 syntax_mpeg4->video_signal_type = 0; /* not present */
488 syntax_mpeg4->video_format = 5; /* unspecified */
489 syntax_mpeg4->video_range = 0;
490 syntax_mpeg4->colour_description = 0; /* not present */
491 syntax_mpeg4->colour_primaries = 2; /* unknown */
492 syntax_mpeg4->transfer_characteristics = 2; /* unknown */
493 syntax_mpeg4->matrix_coefficients = 2; /* unknown */
494
495
496 /* assign values depending on flags */
497 if(flags & FAME_SYNTAX_ARBITRARY_SHAPE)
498 syntax_mpeg4->video_object_layer_shape = MPEG4_Video_Object_Layer_Shape_Binary;
499 else
500 syntax_mpeg4->video_object_layer_shape = MPEG4_Video_Object_Layer_Shape_Rectangular;
501
502 if(flags & FAME_SYNTAX_LOSSLESS_SHAPE)
503 syntax_mpeg4->change_conv_ratio_disable=1;
504 else
505 syntax_mpeg4->change_conv_ratio_disable=0;
506
507 /* fill in quantization tables */
508 if(*intra_matrix) {
509 int i;
510
511 syntax_mpeg4->load_intra_quant_mat=1;
512 for(i = 0; i < 64; i++)
513 syntax_mpeg4->intra_quant_mat[i] = (*intra_matrix)[mpeg4_zigzag_table[i]];
514 } else {
515 syntax_mpeg4->load_intra_quant_mat=0;
516 *intra_matrix = mpeg4_intra_quantisation_table;
517 }
518
519 if(*inter_matrix) {
520 int i;
521
522 syntax_mpeg4->load_nonintra_quant_mat=1;
523 for(i = 0; i < 64; i++)
524 syntax_mpeg4->nonintra_quant_mat[i] = (*inter_matrix)[mpeg4_zigzag_table[i]];
525 } else {
526 syntax_mpeg4->load_nonintra_quant_mat=0;
527 *inter_matrix = mpeg4_inter_quantisation_table;
528 }
529
530 /* fill in intra DC quantizer values */
531 for(qscale = 0; qscale < 32; qscale++) {
532 if(qscale >= 1 && qscale <= 4) {
533 syntax_mpeg4->y_dc_scaler[qscale] = 8;
534 syntax_mpeg4->c_dc_scaler[qscale] = 8;
535 }
536 if(qscale >= 5 && qscale <= 8) {
537 syntax_mpeg4->y_dc_scaler[qscale] = qscale << 1;
538 syntax_mpeg4->c_dc_scaler[qscale] = (qscale+13) >> 1;
539 }
540 if(qscale >= 9 && qscale <= 24) {
541 syntax_mpeg4->y_dc_scaler[qscale] = qscale + 8;
542 syntax_mpeg4->c_dc_scaler[qscale] = (qscale+13) >> 1;
543 }
544 if(qscale >= 25 && qscale <= 31) {
545 syntax_mpeg4->y_dc_scaler[qscale] = (qscale << 1) - 16;
546 syntax_mpeg4->c_dc_scaler[qscale] = qscale - 6;
547 }
548
549 intra_dc_y_scale_table[qscale] = syntax_mpeg4->y_dc_scaler[qscale];
550 intra_dc_c_scale_table[qscale] = syntax_mpeg4->c_dc_scaler[qscale];
551 }
552
553 /* Initialize symbols for shape */
554 syntax_mpeg4->symbol = (int *) fame_malloc(2048*sizeof(int));
555 mpeg4_init_symbol(syntax_mpeg4->symbol);
556
557 /* MPEG-4 uses global mismatch control */
558 *mismatch_type = fame_mismatch_global;
559 }
560
mpeg4_close(fame_syntax_t * syntax)561 static void mpeg4_close(fame_syntax_t *syntax)
562 {
563 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
564 int i;
565
566 syntax_mpeg4->intra_table -= 64*255; /* uncenter intra vlc table */
567 syntax_mpeg4->inter_table -= 64*255; /* uncenter inter vlc table */
568 fame_free(syntax_mpeg4->symbol);
569 fame_free(syntax_mpeg4->intra_table);
570 fame_free(syntax_mpeg4->inter_table);
571 for(i = 0; i < syntax_mpeg4->mb_width; i++) {
572 fame_free(syntax_mpeg4->y_pred_v[0][i]);
573 fame_free(syntax_mpeg4->y_pred_v[1][i]);
574 fame_free(syntax_mpeg4->cr_pred_v[i]);
575 fame_free(syntax_mpeg4->cb_pred_v[i]);
576 }
577 fame_free(syntax_mpeg4->y_pred_v[0]);
578 fame_free(syntax_mpeg4->y_pred_v[1]);
579 fame_free(syntax_mpeg4->cr_pred_v);
580 fame_free(syntax_mpeg4->cb_pred_v);
581 fame_free(syntax_mpeg4->y_pred_h[0]);
582 fame_free(syntax_mpeg4->y_pred_h[1]);
583 fame_free(syntax_mpeg4->y_pred_h[2]);
584 fame_free(syntax_mpeg4->cr_pred_h[0]);
585 fame_free(syntax_mpeg4->cb_pred_h[0]);
586 fame_free(syntax_mpeg4->cr_pred_h[1]);
587 fame_free(syntax_mpeg4->cb_pred_h[1]);
588 fame_free(syntax_mpeg4->pred[0]);
589 fame_free(syntax_mpeg4->pred[1]);
590 fame_free(syntax_mpeg4->pred[2]);
591 fame_free(syntax_mpeg4->pred[3]);
592 fame_free(syntax_mpeg4->pred[4]);
593 fame_free(syntax_mpeg4->pred[5]);
594 fame_free(syntax_mpeg4->diff[0]);
595 fame_free(syntax_mpeg4->diff[1]);
596 fame_free(syntax_mpeg4->diff[2]);
597 fame_free(syntax_mpeg4->diff[3]);
598 fame_free(syntax_mpeg4->diff[4]);
599 fame_free(syntax_mpeg4->diff[5]);
600 fame_free(syntax_mpeg4->cae_v->buffer);
601 fame_free(syntax_mpeg4->cae_h->buffer);
602 fame_free(syntax_mpeg4->cae_v);
603 fame_free(syntax_mpeg4->cae_h);
604 fame_free(syntax_mpeg4->motion_pred);
605 }
606
mpeg4_use(fame_syntax_t * syntax,unsigned char * buffer,int size)607 static void mpeg4_use(fame_syntax_t *syntax,
608 unsigned char *buffer,
609 int size)
610 {
611 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
612
613 bitbuffer_init(&syntax_mpeg4->buffer, buffer, size);
614 }
615
mpeg4_flush(fame_syntax_t * syntax)616 static int mpeg4_flush(fame_syntax_t *syntax)
617 {
618 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
619
620 return(bitbuffer_flush(&syntax_mpeg4->buffer));
621 }
622
mpeg4_start_sequence(fame_syntax_t * syntax,int width,int height,int fps_num,int fps_den,int size,int bitrate)623 static void mpeg4_start_sequence(fame_syntax_t *syntax,
624 int width,
625 int height,
626 int fps_num,
627 int fps_den,
628 int size,
629 int bitrate)
630 {
631 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
632 fame_bitbuffer_t *buff;
633
634 buff = &syntax_mpeg4->buffer;
635
636 syntax_mpeg4->fps_num = fps_num;
637 syntax_mpeg4->fps_den = fps_den;
638
639 /* Video Object Layer */
640 syntax_mpeg4->short_video_header = 0;
641 syntax_mpeg4->random_accessible_vol = 0;
642 syntax_mpeg4->video_object_type_indication = MPEG4_Video_Object_Type_SimpleObject;
643 syntax_mpeg4->is_object_layer_identifier=0;
644 syntax_mpeg4->video_object_layer_verid = 1;
645 syntax_mpeg4->video_object_layer_priority = 1;
646 syntax_mpeg4->aspect_ratio_info = 1; /* square */
647 syntax_mpeg4->par_width = 1;
648 syntax_mpeg4->par_height = 1;
649 syntax_mpeg4->vol_control_parameters = 0;
650 syntax_mpeg4->video_object_layer_shape_extension = 0;
651 syntax_mpeg4->vop_time_increment_resolution=fps_num;
652 syntax_mpeg4->fixed_vop_time_increment=fps_den;
653 syntax_mpeg4->fixed_vop_rate=1;
654 syntax_mpeg4->video_object_layer_width = width;
655 syntax_mpeg4->video_object_layer_height = height;
656 syntax_mpeg4->interlaced=0;
657 syntax_mpeg4->obmc_disable=1;
658 syntax_mpeg4->sprite_enable=0;
659 syntax_mpeg4->sadct_disable=1;
660 syntax_mpeg4->not_8_bit=0;
661 syntax_mpeg4->quant_precision=5;
662 syntax_mpeg4->bits_per_pixel=8;
663 syntax_mpeg4->quant_type=1; /* MPEG-4 */
664 syntax_mpeg4->quarter_sample=0;
665 syntax_mpeg4->complexity_estimation_disable=1;
666 syntax_mpeg4->resync_marker_disable=0;
667 syntax_mpeg4->data_partitionned=0;
668 syntax_mpeg4->reversible_vlc=0;
669 syntax_mpeg4->newpred_enable=0;
670 syntax_mpeg4->reduced_resolution_vop_enable=0;
671 syntax_mpeg4->scalability=0;
672
673 syntax_mpeg4->vop_time_increment=0;
674
675
676
677 syntax_mpeg4->vop_reduced_resolution=0;
678 syntax_mpeg4->interlaced=0;
679
680 #ifndef OPENDIVX_COMPATIBILITY
681 bitbuffer_write(buff,MPEG4_SEQUENCE_START_CODE,32);
682 bitbuffer_write(buff,syntax_mpeg4->profile_and_level_indication,8);
683 bitbuffer_write(buff,MPEG4_VISUAL_OBJ_START_CODE,32);
684 bitbuffer_write(buff,syntax_mpeg4->is_visual_object_identifier,1);
685 if ( syntax_mpeg4->is_visual_object_identifier )
686 {
687 /* TODO */
688 }
689 bitbuffer_write(buff,syntax_mpeg4->visual_object_type,4);
690 if ( (syntax_mpeg4->visual_object_type == MPEG4_Visual_Object_Type_VideoID) ||
691 (syntax_mpeg4->visual_object_type == MPEG4_Visual_Object_Type_still_textureID))
692 {
693 bitbuffer_write(buff,syntax_mpeg4->video_signal_type,1);
694 if(syntax_mpeg4->video_signal_type)
695 {
696 /* TODO */
697 }
698 }
699
700 /* Next Start Code */
701
702 mpeg4_next_start_code(buff);
703 #endif
704
705 /* if syntax_mpeg4->visual_object_type == MPEG4_Visual_Object_Type_VideoID
706 * on ne fait rien d'autre */
707 bitbuffer_write(buff,MPEG4_VIDEO_OBJ_START_CODE, 32);
708 bitbuffer_write(buff,MPEG4_VIDEO_OBJ_LAYER_START_CODE, 32);
709 syntax_mpeg4->short_video_header=0;
710 bitbuffer_write(buff,syntax_mpeg4->random_accessible_vol,1);
711 bitbuffer_write(buff,syntax_mpeg4->video_object_type_indication,8);
712 if (syntax_mpeg4->video_object_type_indication == MPEG4_Video_Object_Type_FineGranularityScalable )
713 {
714 /* Not Supported */
715 }
716 else
717 {
718 bitbuffer_write(buff,syntax_mpeg4->is_object_layer_identifier, 1 );
719 if(syntax_mpeg4->is_object_layer_identifier)
720 {
721 /* TODO */
722 }
723
724 bitbuffer_write(buff,syntax_mpeg4->aspect_ratio_info,4);
725 if (syntax_mpeg4->aspect_ratio_info == MPEG4_Aspect_Ratio_Info_ExtendedPAR )
726 {
727 /* TODO */
728 }
729 bitbuffer_write(buff,syntax_mpeg4->vol_control_parameters, 1);
730 if (syntax_mpeg4->vol_control_parameters)
731 {
732 /* TODO */
733 }
734 bitbuffer_write(buff,syntax_mpeg4->video_object_layer_shape,2);
735 if ((syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_Grayscale) &&
736 (syntax_mpeg4->video_object_layer_verid != 1))
737 {
738 /* TODO */
739 }
740 bitbuffer_write(buff,1,1); /* Marker */
741 bitbuffer_write(buff,syntax_mpeg4->vop_time_increment_resolution, 16);
742 bitbuffer_write(buff,1,1); /* Marker */
743 bitbuffer_write(buff,syntax_mpeg4->fixed_vop_rate,1);
744 if(syntax_mpeg4->fixed_vop_rate);
745 {
746 bitbuffer_write(buff,syntax_mpeg4->fixed_vop_time_increment,
747 get_min_bit(syntax_mpeg4->vop_time_increment_resolution));
748
749 }
750 if(syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_BinaryOnly )
751 {
752 if(syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_Rectangular )
753 {
754 bitbuffer_write(buff,1,1); /* Marker */
755 bitbuffer_write(buff,syntax_mpeg4->video_object_layer_width,13);
756 bitbuffer_write(buff,1,1); /* Marker */
757 bitbuffer_write(buff,syntax_mpeg4->video_object_layer_height,13);
758 bitbuffer_write(buff,1,1); /* Marker */
759 }
760 bitbuffer_write(buff,syntax_mpeg4->interlaced,1);
761 bitbuffer_write(buff,syntax_mpeg4->obmc_disable,1);
762 if (syntax_mpeg4->video_object_layer_verid == 0x01 )
763 {
764 bitbuffer_write(buff,syntax_mpeg4->sprite_enable,1);
765 }
766 else
767 bitbuffer_write(buff,syntax_mpeg4->sprite_enable,2);
768 /* TODO test sprite */
769
770 if ((syntax_mpeg4->video_object_layer_verid != 0x01) &&
771 (syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_Rectangular ))
772 bitbuffer_write(buff,syntax_mpeg4->sadct_disable,1);
773 bitbuffer_write(buff,syntax_mpeg4->not_8_bit,1);
774 if (syntax_mpeg4->not_8_bit)
775 {
776 bitbuffer_write(buff,syntax_mpeg4->quant_precision,4);
777 bitbuffer_write(buff,syntax_mpeg4->bits_per_pixel,4);
778 }
779 if ( syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_Grayscale )
780 {
781 /* not supported */
782 }
783 bitbuffer_write(buff,syntax_mpeg4->quant_type,1);
784 if ( syntax_mpeg4->quant_type)
785 {
786 int i;
787
788 bitbuffer_write(buff,syntax_mpeg4->load_intra_quant_mat,1);
789 if ( syntax_mpeg4->load_intra_quant_mat )
790 for(i = 0; i < 64; i++) /* already in zigzag order */
791 bitbuffer_write(buff,syntax_mpeg4->intra_quant_mat[i],8);
792
793 bitbuffer_write(buff,syntax_mpeg4->load_nonintra_quant_mat,1);
794 if ( syntax_mpeg4->load_nonintra_quant_mat )
795 for(i = 0; i < 64; i++) /* already in zigzag order */
796 bitbuffer_write(buff,syntax_mpeg4->nonintra_quant_mat[i],8);
797
798 if( syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_Grayscale ) {
799 /* not supported */
800 }
801 }
802 if(syntax_mpeg4->video_object_layer_verid != 0x01)
803 bitbuffer_write(buff,syntax_mpeg4->quarter_sample,1);
804 bitbuffer_write(buff,syntax_mpeg4->complexity_estimation_disable,1);
805 if(!syntax_mpeg4->complexity_estimation_disable)
806 {
807 /* TODO */
808 }
809 bitbuffer_write(buff,syntax_mpeg4->resync_marker_disable,1);
810 bitbuffer_write(buff,syntax_mpeg4->data_partitionned,1);
811 if(syntax_mpeg4->data_partitionned)
812 bitbuffer_write(buff,syntax_mpeg4->reversible_vlc,1);
813 if (syntax_mpeg4->video_object_layer_verid != 0x01 )
814 {
815 bitbuffer_write(buff,syntax_mpeg4->newpred_enable,1);
816 if (syntax_mpeg4->newpred_enable)
817 {
818 /* TODO */
819 }
820 bitbuffer_write(buff,syntax_mpeg4->reduced_resolution_vop_enable,1);
821 }
822 bitbuffer_write(buff,syntax_mpeg4->scalability,1);
823 if (syntax_mpeg4->scalability)
824 {
825 /* TODO */
826 }
827
828 } else
829 {
830 /* Binary Only not (yet) supported */
831 }
832
833 /* Next Start Code */
834 mpeg4_next_start_code(buff);
835
836 /* User Data */
837
838 }
839
840 }
841
mpeg4_start_GOP(fame_syntax_t * syntax,int frame)842 static void mpeg4_start_GOP(fame_syntax_t *syntax, int frame)
843 {
844 #ifndef OPENDIVX_COMPATIBILITY
845 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
846 fame_bitbuffer_t *buff;
847 int fps_num, fps_den;
848
849 fps_num = syntax_mpeg4->fps_num;
850 fps_den = syntax_mpeg4->fps_den;
851
852 buff = &syntax_mpeg4->buffer;
853
854 /* Group Of VOP default values */
855 syntax_mpeg4->closed_gov=1;
856 syntax_mpeg4->broken_link=0;
857
858 syntax_mpeg4->vop_time_increment=0;
859
860 bitbuffer_write(buff,MPEG4_GVOP_START_CODE, 32);
861 /* timecount hours */
862 bitbuffer_write(buff, (frame*fps_den/(3600*fps_num)) & 0x1f, 5);
863 /* timecount minutes */
864 bitbuffer_write(buff, ((frame*fps_den/(60*fps_num))%60) & 0x3f, 6);
865 /* marker */
866 bitbuffer_write(buff, 1, 1);
867 /* timecount seconds */
868 bitbuffer_write(buff, ((frame*fps_den/fps_num)%60) & 0x3f, 6);
869
870 bitbuffer_write(buff, syntax_mpeg4->closed_gov, 1);
871 bitbuffer_write(buff, syntax_mpeg4->broken_link, 1);
872 /* Next Start Code */
873 mpeg4_next_start_code(buff);
874 #endif
875 }
876
mpeg4_start_picture(fame_syntax_t * syntax,char frame_type,int frame_number,fame_box_t * box,int rounding_control,int search_range)877 static void mpeg4_start_picture(fame_syntax_t *syntax,
878 char frame_type,
879 int frame_number,
880 fame_box_t *box,
881 int rounding_control,
882 int search_range)
883 {
884 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
885 fame_bitbuffer_t *buff;
886 int tmp;
887 unsigned int modulo_time_base;
888
889
890 buff = &syntax_mpeg4->buffer;
891
892 switch(frame_type) {
893 case 'I':
894 syntax_mpeg4->vop_coding_type = MPEG4_I_FRAME;
895 break;
896 case 'P':
897 syntax_mpeg4->vop_coding_type = MPEG4_P_FRAME;
898 break;
899 default:
900 FAME_ERROR("Unsupported picture coding type %c", frame_type);
901 return;
902 }
903
904 /* Video Object Plane */
905 syntax_mpeg4->vop_rounding_type = rounding_control;
906 syntax_mpeg4->vop_reduced_resolution = 0;
907 syntax_mpeg4->vop_horizontal_mc_spatial_ref=box->x;
908 syntax_mpeg4->vop_vertical_mc_spatial_ref=box->y;
909 syntax_mpeg4->vop_width=box->w;
910 syntax_mpeg4->vop_height=box->h;
911 syntax_mpeg4->vop_constant_alpha=0;
912 syntax_mpeg4->vop_constant_alpha_value=128;
913 syntax_mpeg4->intra_dc_vlc_thr=0; /* use intra DC vlc for all DC coefficients */
914
915 tmp = (box->w+15)/16 * (box->h+15)/16;
916
917 syntax_mpeg4->macroblock_number_size = get_min_bit(tmp);
918
919 /* compute fcode */
920 syntax_mpeg4->vop_fcode_forward =
921 syntax_mpeg4->vop_fcode_backward =
922 fame_max(1, get_min_bit(search_range-1)-3);
923 if(syntax_mpeg4->vop_fcode_forward > 7) {
924 FAME_WARNING("vop_fcode_forward > 7, search range too big.\n");
925 syntax_mpeg4->vop_fcode_forward = 7;
926 }
927 if(syntax_mpeg4->vop_fcode_backward > 7) {
928 FAME_WARNING("vop_fcode_backward > 7, search range too big.\n");
929 syntax_mpeg4->vop_fcode_backward = 7;
930 }
931
932 bitbuffer_write(buff, MPEG4_VOP_START_CODE, 32); /* picture start code */
933 bitbuffer_write(buff, syntax_mpeg4->vop_coding_type,2);
934
935 /* Modulo time base */
936 modulo_time_base = syntax_mpeg4->vop_time_increment / syntax_mpeg4->vop_time_increment_resolution;
937 if (modulo_time_base) {
938 bitbuffer_write(buff, ((1 << modulo_time_base) - 1), modulo_time_base);
939 syntax_mpeg4->vop_time_increment %= syntax_mpeg4->vop_time_increment_resolution;
940 }
941 bitbuffer_write(buff,0,1); /* end of modulo time base */
942 bitbuffer_write(buff,1,1); /* Marker */
943 bitbuffer_write(buff,syntax_mpeg4->vop_time_increment%syntax_mpeg4->vop_time_increment_resolution, get_min_bit(syntax_mpeg4->vop_time_increment_resolution));
944
945 syntax_mpeg4->vop_time_increment += syntax_mpeg4->fixed_vop_time_increment;
946 bitbuffer_write(buff,1,1);
947 bitbuffer_write(buff,1,1); /* VOP coded */
948 if(syntax_mpeg4->newpred_enable)
949 {
950 /* not supported */
951 }
952 if( (syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_BinaryOnly ) &&
953 (syntax_mpeg4->vop_coding_type == MPEG4_P_FRAME))
954 bitbuffer_write(buff,syntax_mpeg4->vop_rounding_type,1);
955 if ( (syntax_mpeg4->reduced_resolution_vop_enable) &&
956 (syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_Rectangular ) &&
957 ((syntax_mpeg4->vop_coding_type == MPEG4_I_FRAME) || (syntax_mpeg4->vop_coding_type == MPEG4_P_FRAME )))
958 bitbuffer_write(buff,syntax_mpeg4->vop_reduced_resolution,1);
959
960 if(syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_Rectangular )
961 {
962 /* TODO: test Sprite */
963 {
964 bitbuffer_write(buff,syntax_mpeg4->vop_width & 0x1fff,13);
965 bitbuffer_write(buff,1,1); /* Marker */
966 bitbuffer_write(buff,syntax_mpeg4->vop_height & 0x1fff,13);
967 bitbuffer_write(buff,1,1); /* Marker */
968 bitbuffer_write(buff,syntax_mpeg4->vop_horizontal_mc_spatial_ref & 0x1fff,13);
969 bitbuffer_write(buff,1,1); /* Marker */
970 bitbuffer_write(buff,syntax_mpeg4->vop_vertical_mc_spatial_ref & 0x1fff,13);
971 bitbuffer_write(buff,1,1); /* Marker */
972 }
973 bitbuffer_write(buff,syntax_mpeg4->change_conv_ratio_disable,1);
974 bitbuffer_write(buff,syntax_mpeg4->vop_constant_alpha,1);
975 if(syntax_mpeg4->vop_constant_alpha)
976 bitbuffer_write(buff,syntax_mpeg4->vop_constant_alpha_value,8)
977 }
978
979 if (syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_BinaryOnly )
980 if (!syntax_mpeg4->complexity_estimation_disable)
981 {
982 /* not supported */
983 }
984 if (syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_BinaryOnly )
985 {
986 bitbuffer_write(buff,syntax_mpeg4->intra_dc_vlc_thr,3);
987 if(syntax_mpeg4->interlaced)
988 {
989 /* not supported */
990 }
991 }
992
993 /* TODO: sprites */
994 {
995
996 }
997
998 syntax_mpeg4->flag_video_packet_header = 0;
999
1000 /* restart motion predictor */
1001 syntax_mpeg4->mv_pred = syntax_mpeg4->motion_pred;
1002 }
1003
mpeg4_reset_pred(fame_syntax_t * syntax)1004 static void inline mpeg4_reset_pred(fame_syntax_t *syntax)
1005 {
1006 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1007 int i;
1008
1009 /* horizontal predictors */
1010 FASTCOPY16(syntax_mpeg4->y_pred_h[0], syntax_mpeg4->pred_default);
1011 FASTCOPY16(syntax_mpeg4->y_pred_h[1], syntax_mpeg4->pred_default);
1012 FASTCOPY16(syntax_mpeg4->y_pred_h[2], syntax_mpeg4->pred_default);
1013 FASTCOPY16(syntax_mpeg4->cr_pred_h[0], syntax_mpeg4->pred_default);
1014 FASTCOPY16(syntax_mpeg4->cr_pred_h[1], syntax_mpeg4->pred_default);
1015 FASTCOPY16(syntax_mpeg4->cb_pred_h[0], syntax_mpeg4->pred_default);
1016 FASTCOPY16(syntax_mpeg4->cb_pred_h[1], syntax_mpeg4->pred_default);
1017
1018 /* vertical predictors */
1019 for(i = 0; i < syntax_mpeg4->mb_width; i++) {
1020 FASTCOPY16(syntax_mpeg4->y_pred_v[0][i], syntax_mpeg4->pred_default);
1021 FASTCOPY16(syntax_mpeg4->y_pred_v[1][i], syntax_mpeg4->pred_default);
1022 FASTCOPY16(syntax_mpeg4->cr_pred_v[i], syntax_mpeg4->pred_default);
1023 FASTCOPY16(syntax_mpeg4->cb_pred_v[i], syntax_mpeg4->pred_default);
1024 }
1025
1026 /* motion predictors */
1027 memset(syntax_mpeg4->motion_pred, 0,
1028 4*syntax_mpeg4->mb_height*
1029 syntax_mpeg4->mb_width*sizeof(fame_motion_vector_t));
1030 }
1031
mpeg4_start_slice(fame_syntax_t * syntax,int vpos,int length,unsigned char qscale)1032 static void mpeg4_start_slice(fame_syntax_t *syntax,
1033 int vpos,
1034 int length,
1035 unsigned char qscale)
1036 {
1037 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1038 fame_bitbuffer_t *buff;
1039
1040 /* compute dc_scaler */
1041 if(qscale == 0 || qscale > 31) {
1042 FAME_WARNING("Invalid quantisation scale %d (1-31), setting to 8.\n",
1043 qscale);
1044 }
1045
1046 buff = &syntax_mpeg4->buffer;
1047
1048 /* Video Packet default value */
1049 syntax_mpeg4->vop_quant = syntax_mpeg4->quant_scale = qscale;
1050 syntax_mpeg4->vop_shape_coding_type = 0; /* always intra shape coding */
1051 syntax_mpeg4->header_extension_code = 0;
1052 syntax_mpeg4->macroblock_number = vpos * ((syntax_mpeg4->vop_width+15) / 16);
1053
1054 if (!syntax_mpeg4->flag_video_packet_header)
1055 {
1056 if (syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_BinaryOnly )
1057 {
1058 bitbuffer_write(buff,syntax_mpeg4->vop_quant & ((1 << syntax_mpeg4->quant_precision)-1),syntax_mpeg4->quant_precision);
1059 if (syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_Grayscale )
1060 {
1061 /* Not supported */
1062 }
1063 if (syntax_mpeg4->vop_coding_type != MPEG4_I_FRAME )
1064 bitbuffer_write(buff,syntax_mpeg4->vop_fcode_forward & 7,3);
1065 if (syntax_mpeg4->vop_coding_type == MPEG4_B_FRAME )
1066 bitbuffer_write(buff,syntax_mpeg4->vop_fcode_backward & 7,3);
1067 if(!syntax_mpeg4->scalability)
1068 {
1069 if ((syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_Rectangular) &&
1070 (syntax_mpeg4->vop_coding_type != MPEG4_I_FRAME ))
1071 bitbuffer_write(buff,syntax_mpeg4->vop_shape_coding_type,1);
1072 }else
1073 {
1074 /* Not supported */
1075 }
1076 } else
1077 {
1078 /* Not supported */
1079 }
1080 syntax_mpeg4->flag_video_packet_header=1;
1081 } else
1082 {
1083 int resync_length = 0;
1084
1085 /* compute resync marker length */
1086 if (syntax_mpeg4->vop_coding_type == MPEG4_I_FRAME ||
1087 syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_BinaryOnly)
1088 resync_length = 16;
1089 else {
1090 if(syntax_mpeg4->vop_coding_type == MPEG4_P_FRAME)
1091 resync_length = 15+syntax_mpeg4->vop_fcode_forward;
1092 if(syntax_mpeg4->vop_coding_type == MPEG4_B_FRAME)
1093 resync_length = fame_max(15+fame_max(syntax_mpeg4->vop_fcode_forward, syntax_mpeg4->vop_fcode_backward), 17);
1094 }
1095 /* resync marker */
1096 bitbuffer_write(buff, 0, resync_length);
1097 bitbuffer_write(buff, 1, 1);
1098
1099 if(syntax_mpeg4->video_object_layer_shape != MPEG4_Video_Object_Layer_Shape_Rectangular)
1100 bitbuffer_write(buff,syntax_mpeg4->header_extension_code,1);
1101 if(syntax_mpeg4->header_extension_code) /* TODO: test sprite_enable */
1102 {
1103 /* Not implemented */
1104 }
1105 bitbuffer_write(buff,syntax_mpeg4->macroblock_number,syntax_mpeg4->macroblock_number_size);
1106 if(syntax_mpeg4->video_object_layer_shape!= MPEG4_Video_Object_Layer_Shape_BinaryOnly)
1107 bitbuffer_write(buff,syntax_mpeg4->quant_scale & 0x1f, 5);
1108 if(syntax_mpeg4->video_object_layer_shape == MPEG4_Video_Object_Layer_Shape_Rectangular)
1109 bitbuffer_write(buff,syntax_mpeg4->header_extension_code,1);
1110 if(syntax_mpeg4->header_extension_code)
1111 {
1112 /* Not Implemented */
1113 }
1114
1115 if (syntax_mpeg4->newpred_enable)
1116 {
1117 /* Not implemented */
1118 }
1119
1120 }
1121
1122 /* reset the DC predictors to their original values */
1123 mpeg4_reset_pred(syntax);
1124 }
1125
mpeg4_end_slice(fame_syntax_t * syntax)1126 static void mpeg4_end_slice(fame_syntax_t *syntax) {
1127 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1128
1129 mpeg4_next_start_code(&syntax_mpeg4->buffer); /* next start code */
1130 }
1131
mpeg4_end_sequence(fame_syntax_t * syntax)1132 static void mpeg4_end_sequence(fame_syntax_t *syntax)
1133 {
1134 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1135
1136 /* end sequence code */
1137 bitbuffer_write(&syntax_mpeg4->buffer, MPEG4_SEQUENCE_END_CODE, 32);
1138 }
1139
mpeg4_predict_vector(fame_syntax_t * syntax,int mb_x,int mb_y,int k,fame_motion_vector_t * mv)1140 static void mpeg4_predict_vector(fame_syntax_t *syntax,
1141 int mb_x,
1142 int mb_y,
1143 int k,
1144 fame_motion_vector_t *mv)
1145 {
1146 #define MEDIAN(a,b,c) ((b)<(a))?(((c)>(a))?(a):(((c)<(b))?(b):(c))):(((c)<(a))?(a):(((c)>(b))?(b):(c)))
1147
1148 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1149 fame_motion_vector_t *predictor1, *predictor2, *predictor3, *mv_pred;
1150 int pitch;
1151 int border1, border2, border3;
1152 int mb_addr, slice_addr;
1153
1154 /* HACK: we use count as a flag for vector validity */
1155 /* TODO: thus, checking borders is probably not needed anymore */
1156 /* though checking video packets boundaries is. */
1157 pitch = syntax_mpeg4->mb_width;
1158 slice_addr = syntax_mpeg4->macroblock_number;
1159 mb_addr = mb_y*syntax_mpeg4->mb_width+mb_x;
1160
1161 border1 = (mb_x == 0) || (mb_addr <= slice_addr);
1162 border2 = (mb_addr - pitch < slice_addr);
1163 border3 = (mb_x == pitch - 1) || (mb_addr - pitch + 1 < slice_addr);
1164
1165 pitch = syntax_mpeg4->mb_width*4;
1166 mv_pred = syntax_mpeg4->mv_pred;
1167
1168 switch(k) {
1169 case 0:
1170 predictor1 = mv_pred - 3;
1171 predictor2 = mv_pred - pitch + 2;
1172 predictor3 = mv_pred - pitch + 6;
1173 break;
1174 /* WARNING: count must be valid in 'mv' past this point */
1175 case 1:
1176 predictor1 = &mv[0]; border1 = 0;
1177 predictor2 = mv_pred - pitch + 3;
1178 predictor3 = mv_pred - pitch + 6;
1179 break;
1180 case 2:
1181 predictor1 = mv_pred - 1;
1182 predictor2 = &mv[0]; border2 = 0;
1183 predictor3 = &mv[1]; border3 = 0;
1184 break;
1185 case 3:
1186 predictor1 = &mv[2]; border1 = 0;
1187 predictor2 = &mv[0]; border2 = 0;
1188 predictor3 = &mv[1]; border3 = 0;
1189 break;
1190 default: /* invalid k */
1191 predictor1 = predictor2 = predictor3 = NULL;
1192 break;
1193 }
1194
1195 if(border1 || !predictor1->count) {
1196 if(border2 || !predictor2->count) {
1197 if(border3 || !predictor3->count) {
1198 /* no pred */
1199 mv_pred[k].dx = 0;
1200 mv_pred[k].dy = 0;
1201 } else {
1202 /* only p3 */
1203 mv_pred[k].dx = predictor3->dx;
1204 mv_pred[k].dy = predictor3->dy;
1205 }
1206 } else {
1207 if(border3 || !predictor3->count) {
1208 /* p2 only */
1209 mv_pred[k].dx = predictor2->dx;
1210 mv_pred[k].dy = predictor2->dx;
1211 } else {
1212 /* p2, p3 */
1213 mv_pred[k].dx = MEDIAN(0,predictor2->dx,predictor3->dx);
1214 mv_pred[k].dy = MEDIAN(0,predictor2->dy,predictor3->dy);
1215 }
1216 }
1217 } else if(border3 || !predictor3->count) {
1218 if(border2 || !predictor2->count) {
1219 /* p1 only */
1220 mv_pred[k].dx = predictor1->dx;
1221 mv_pred[k].dy = predictor1->dy;
1222 } else {
1223 /* p1, p2 */
1224 mv_pred[k].dx = MEDIAN(predictor1->dx,predictor2->dx,0);
1225 mv_pred[k].dy = MEDIAN(predictor1->dy,predictor2->dy,0);
1226 }
1227 } else {
1228 if(border2 || !predictor2->count) {
1229 /* p1, p3 */
1230 mv_pred[k].dx = MEDIAN(predictor1->dx,0,predictor3->dx);
1231 mv_pred[k].dy = MEDIAN(predictor1->dx,0,predictor3->dx);
1232 } else {
1233 /* p1, p2, p3 */
1234 mv_pred[k].dx = MEDIAN(predictor1->dx, predictor2->dx, predictor3->dx);
1235 mv_pred[k].dy = MEDIAN(predictor1->dy, predictor2->dy, predictor3->dy);
1236 }
1237 }
1238
1239 if(k == 0) { /* HACK: fill in the 16x16 vector with the predictor */
1240 mv[0].dx = mv_pred[0].dx;
1241 mv[0].dy = mv_pred[0].dy;
1242 }
1243 }
1244
mpeg4_arithmetic_bit(fame_syntax_cae_t * cae,unsigned char bit)1245 static void inline mpeg4_arithmetic_bit(fame_syntax_cae_t *cae, unsigned char bit)
1246 {
1247 *cae->sequence++ = bit;
1248
1249 /* avoid start code emulation */
1250 if (bit == 0) {
1251 cae->nzeros--;
1252 if (cae->nzeros == 0)
1253 {
1254 *cae->sequence++ = 1;
1255 cae->nonzero = 1;
1256 cae->nzeros = CAE_MAX_MIDDLE;
1257 }
1258 } else {
1259 cae->nonzero = 1;
1260 cae->nzeros = CAE_MAX_MIDDLE;
1261 }
1262 }
1263
mpeg4_arithmetic_follow(fame_syntax_cae_t * cae,unsigned char bit)1264 static void inline mpeg4_arithmetic_follow(fame_syntax_cae_t *cae, unsigned char bit)
1265 {
1266 if (!cae->first_bit)
1267 mpeg4_arithmetic_bit(cae, bit);
1268 else
1269 cae->first_bit = 0;
1270
1271 while(cae->bits_to_follow > 0) {
1272 mpeg4_arithmetic_bit(cae, !bit);
1273 cae->bits_to_follow--;
1274 }
1275 }
1276
mpeg4_arithmetic_renormalize(fame_syntax_cae_t * cae)1277 static void inline mpeg4_arithmetic_renormalize(fame_syntax_cae_t *cae) {
1278 while (cae->range < CAE_1_4) {
1279 if (cae->lower >= CAE_1_2) {
1280 mpeg4_arithmetic_follow(cae, 1);
1281 cae->lower -= CAE_1_2;
1282 } else {
1283 if (cae->lower + cae->range <= CAE_1_2)
1284 mpeg4_arithmetic_follow(cae, 0);
1285 else {
1286 cae->bits_to_follow++;
1287 cae->lower -= CAE_1_4;
1288 }
1289 }
1290 cae->lower += cae->lower;
1291 cae->range += cae->range;
1292 }
1293 }
1294
mpeg4_arithmetic_enter(fame_syntax_cae_t * cae)1295 static void inline mpeg4_arithmetic_enter(fame_syntax_cae_t *cae)
1296 {
1297 cae->lower = 0;
1298 cae->range = CAE_1_2 - 1;
1299 cae->bits_to_follow = 0;
1300 cae->first_bit = 1;
1301 cae->nzeros = CAE_MAX_HEADING;
1302 cae->nonzero = 0;
1303 cae->sequence = cae->buffer;
1304 }
1305
mpeg4_arithmetic_leave(fame_syntax_cae_t * cae)1306 static void inline mpeg4_arithmetic_leave(fame_syntax_cae_t *cae)
1307 {
1308 int a = (cae->lower) >> 29;
1309 int b = (cae->range + cae->lower) >> 29;
1310 int nbits, bits, i;
1311
1312 if (b == 0) b = 8;
1313
1314 if (b - a >= 4 || (b - a == 3 && (a & 1))) {
1315 nbits = 2;
1316 bits = (a >> 1) + 1;
1317 } else {
1318 nbits = 3;
1319 bits = a + 1;
1320 }
1321
1322 for (i = 1; i <= nbits; i++)
1323 mpeg4_arithmetic_follow(cae, (bits >> (nbits - i)) & 1);
1324
1325 if (cae->nzeros < CAE_MAX_MIDDLE - CAE_MAX_TRAILING ||
1326 cae->nonzero == 0) {
1327 mpeg4_arithmetic_follow(cae, 1);
1328 }
1329 *cae->sequence++ = 0xff;
1330 }
1331
mpeg4_arithmetic_code(fame_syntax_cae_t * cae,int cLPS)1332 static void inline mpeg4_arithmetic_code(fame_syntax_cae_t *cae, int cLPS)
1333 {
1334 signed long rLPS;
1335
1336 rLPS = (cae->range >> 16) * cLPS;
1337
1338 if (rLPS > 0) {
1339 cae->lower += cae->range - rLPS;
1340 cae->range = rLPS;
1341 }
1342 else
1343 cae->range += rLPS;
1344
1345 mpeg4_arithmetic_renormalize(cae);
1346 }
1347
mpeg4_write_intra_bab(fame_syntax_t * syntax,int mb_x,int mb_y,unsigned char * bab,unsigned char * prev_bab,fame_bab_t bab_type)1348 static void inline mpeg4_write_intra_bab(fame_syntax_t *syntax,
1349 int mb_x, int mb_y,
1350 unsigned char *bab,
1351 unsigned char *prev_bab,
1352 fame_bab_t bab_type)
1353 {
1354 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1355 int i, j;
1356 int line;
1357 unsigned char *ptr_h, *ptr_v;
1358 int pitch = syntax_mpeg4->mb_width + 2;
1359 int addr;
1360 int prev_addr[4];
1361
1362 /* initialize arithmetic encoders */
1363 mpeg4_arithmetic_enter(syntax_mpeg4->cae_h);
1364 mpeg4_arithmetic_enter(syntax_mpeg4->cae_v);
1365
1366 /* compute current bab address, add 1 for borders */
1367 addr = mb_y * pitch + pitch + mb_x + 1;
1368
1369 /* compute addresses of previous babs */
1370 prev_addr[0] = addr - 1;
1371 prev_addr[1] = addr - pitch + 1;
1372 prev_addr[2] = addr - pitch;
1373 prev_addr[3] = addr - pitch - 1;
1374
1375 /* compute context number for vlc table indexation */
1376 /* bab = 0 if not_coded */
1377 /* bab = 1 if all_coded */
1378 /* bab = 2 if cae_coded */
1379 /* context = 27*bab[i-1,j-1]+9*bab[i,j-1]+3*bab[i+1,j-1]+bab[i-1,j] */
1380 /* TODO: fix context computation in case of multiple slice */
1381 /* TODO: wrong for P frames */
1382 i = 0;
1383 for(j = 0; j < 4; j++) {
1384 switch(prev_bab[prev_addr[j]]) {
1385 case bab_not_coded:
1386 break;
1387 case bab_all_coded:
1388 i += bab_type_intra_context_weight[j];
1389 break;
1390 case bab_border_16x16:
1391 case bab_border_8x8:
1392 case bab_border_4x4:
1393 i += bab_type_intra_context_weight[j];
1394 i += bab_type_intra_context_weight[j];
1395 break;
1396 }
1397 }
1398
1399 /* save current bab_type for further context computing */
1400 prev_bab[addr] = bab_type;
1401
1402 /* write vlc */
1403 switch(bab_type)
1404 {
1405 case bab_not_coded:
1406 bitbuffer_write(&syntax_mpeg4->buffer, 1, bab_type_intra_vl[i][0]);
1407 return;
1408 case bab_all_coded:
1409 bitbuffer_write(&syntax_mpeg4->buffer, 1, bab_type_intra_vl[i][1]);
1410 return;
1411 case bab_border_16x16:
1412 case bab_border_8x8:
1413 case bab_border_4x4:
1414 bitbuffer_write(&syntax_mpeg4->buffer, 1, bab_type_intra_vl[i][2]);
1415 break;
1416 }
1417
1418 /* no MVDs */
1419
1420 /* horizontal raster order context */
1421 #define CIH0 ((*(ptr_h ))<<0)
1422 #define CIH1 ((*(ptr_h -1))<<1)
1423 #define CIH2 ((*(ptr_h -2))<<2)
1424 #define CIH3 ((*(ptr_h-1*line+2))<<3)
1425 #define CIH4 ((*(ptr_h-1*line+1))<<4)
1426 #define CIH5 ((*(ptr_h-1*line ))<<5)
1427 #define CIH6 ((*(ptr_h-1*line-1))<<6)
1428 #define CIH7 ((*(ptr_h-1*line-2))<<7)
1429 #define CIH8 ((*(ptr_h-2*line+1))<<8)
1430 #define CIH9 ((*(ptr_h-2*line ))<<9)
1431 #define CIH10 ((*(ptr_h-2*line-1))<<10)
1432 #define CIH (CIH0|CIH1|CIH2|CIH3|CIH4|CIH5|CIH6|CIH7|CIH8|CIH9|CIH10)
1433
1434 /* vertical raster order context */
1435 #define CIV0 ((*(ptr_v ))<<0)
1436 #define CIV1 ((*(ptr_v -1*line))<<1)
1437 #define CIV2 ((*(ptr_v -2*line))<<2)
1438 #define CIV3 ((*(ptr_v-1+2*line))<<3)
1439 #define CIV4 ((*(ptr_v-1+1*line))<<4)
1440 #define CIV5 ((*(ptr_v-1 ))<<5)
1441 #define CIV6 ((*(ptr_v-1-1*line))<<6)
1442 #define CIV7 ((*(ptr_v-1-2*line))<<7)
1443 #define CIV8 ((*(ptr_v-2+1*line))<<8)
1444 #define CIV9 ((*(ptr_v-2 ))<<9)
1445 #define CIV10 ((*(ptr_v-2-1*line))<<10)
1446 #define CIV (CIV0|CIV1|CIV2|CIV3|CIV4|CIV5|CIV6|CIV7|CIV8|CIV9|CIV10)
1447
1448 switch(bab_type)
1449 {
1450 case bab_border_16x16:
1451 if(!syntax_mpeg4->change_conv_ratio_disable)
1452 bitbuffer_write(&syntax_mpeg4->buffer, 0, 1); /* CR = 1 */
1453 line = 20;
1454 ptr_h = ptr_v = bab+2*line+2; /* skip border */
1455 for(i = 0; i < 16; i++) {
1456 for(j = 0; j < 16; j++) {
1457 mpeg4_arithmetic_code(syntax_mpeg4->cae_h,
1458 syntax_mpeg4->symbol[CIH]);
1459 mpeg4_arithmetic_code(syntax_mpeg4->cae_v,
1460 syntax_mpeg4->symbol[CIV]);
1461 ptr_h++;
1462 ptr_v+=line;
1463 }
1464 ptr_h += 4;
1465 ptr_v += -(line<<4) + 1;
1466 }
1467 break;
1468 case bab_border_8x8:
1469 bitbuffer_write(&syntax_mpeg4->buffer, 2, 2); /* CR = 2 */
1470 line = 12;
1471 ptr_h = ptr_v = bab+2*line+2; /* skip border */
1472 for(i = 0; i < 8; i++) {
1473 for(j = 0; j < 8; j++) {
1474 mpeg4_arithmetic_code(syntax_mpeg4->cae_h,
1475 syntax_mpeg4->symbol[CIH]);
1476 mpeg4_arithmetic_code(syntax_mpeg4->cae_v,
1477 syntax_mpeg4->symbol[CIV]);
1478 ptr_h++;
1479 ptr_v+=line;
1480 }
1481 ptr_h += 4;
1482 ptr_v += -(line<<3) + 1;
1483 }
1484 break;
1485 case bab_border_4x4:
1486 bitbuffer_write(&syntax_mpeg4->buffer, 3, 2); /* CR = 4 */
1487 line = 8;
1488 ptr_h = ptr_v = bab+2*line+2; /* skip border */
1489 for(i = 0; i < 4; i++) {
1490 for(j = 0; j < 4; j++) {
1491 mpeg4_arithmetic_code(syntax_mpeg4->cae_h,
1492 syntax_mpeg4->symbol[CIH]);
1493 mpeg4_arithmetic_code(syntax_mpeg4->cae_v,
1494 syntax_mpeg4->symbol[CIV]);
1495 ptr_h++;
1496 ptr_v+=line;
1497 }
1498 ptr_h += 4;
1499 ptr_v += -(line<<2) + 1;
1500 }
1501 break;
1502
1503 default:
1504 break;
1505 }
1506
1507 mpeg4_arithmetic_leave(syntax_mpeg4->cae_h);
1508 mpeg4_arithmetic_leave(syntax_mpeg4->cae_v);
1509
1510 /* keep the smallest code */
1511 syntax_mpeg4->cae_h->sequence = syntax_mpeg4->cae_h->buffer;
1512 syntax_mpeg4->cae_v->sequence = syntax_mpeg4->cae_v->buffer;
1513 for(i = 0; syntax_mpeg4->cae_h->sequence[i] != 0xff; i++);
1514 for(j = 0; syntax_mpeg4->cae_v->sequence[j] != 0xff; j++);
1515
1516 if(i <= j) {
1517 /* horizontal */
1518 bitbuffer_write(&syntax_mpeg4->buffer, 1, 1); /* don't transpose */
1519 for(j = 0; j < i; j++) {
1520 bitbuffer_write(&syntax_mpeg4->buffer,
1521 syntax_mpeg4->cae_h->sequence[j], 1);
1522 }
1523 }
1524 else {
1525 /* vertical */
1526 bitbuffer_write(&syntax_mpeg4->buffer, 0, 1); /* transpose */
1527 for(i = 0; i < j; i++) {
1528 bitbuffer_write(&syntax_mpeg4->buffer,
1529 syntax_mpeg4->cae_v->sequence[i], 1);
1530 }
1531 }
1532 }
1533
mpeg4_block_intra(fame_syntax_t * syntax,short * block,fame_vlc_t const * table,short v,unsigned char * zigzag,unsigned char coded)1534 static void mpeg4_block_intra(fame_syntax_t *syntax,
1535 short *block,
1536 fame_vlc_t const *table,
1537 short v,
1538 unsigned char *zigzag,
1539 unsigned char coded)
1540 {
1541 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1542 short i;
1543 unsigned long last;
1544 fame_vlc_t const *vlc;
1545 fame_bitbuffer_t * const buffer = &syntax_mpeg4->buffer;
1546 unsigned char * data = buffer->data;
1547 unsigned long shift = buffer->shift;
1548
1549 /* encode DC coefficient */
1550 fast_bitbuffer_write(data, shift, table[v+255].code, table[v+255].length);
1551
1552 /* encode AC coefficients */
1553
1554 if(coded) {
1555 i = 1;
1556 last = 1;
1557
1558 /* i < 64 checking not needed as all-zero block is not coded */
1559 while((v = block[zigzag[i]]) == 0) i++;
1560 do {
1561 /* count zeroes */
1562 vlc = syntax_mpeg4->intra_table +
1563 (mpeg4_table_clip[v] << 6) +
1564 i - last;
1565 last = ++i;
1566 while(i < 64 && (v = block[zigzag[i]]) == 0) i++;
1567
1568 /* write code */
1569 if(i != 64) {
1570 fast_bitbuffer_write(data, shift, vlc->code, vlc->length);
1571 } else {
1572 vlc += 64*511;
1573 fast_bitbuffer_write(data, shift, vlc->code, vlc->length);
1574 break;
1575 }
1576 } while(1);
1577 }
1578
1579 buffer->data = data;
1580 buffer->shift = shift;
1581 }
1582
mpeg4_write_intra_mb(fame_syntax_t * syntax,int mb_x,int mb_y,short * blocks[6],unsigned char * bab,unsigned char * bab_map,fame_bab_t bab_type,int dquant,unsigned char pattern)1583 static int mpeg4_write_intra_mb(fame_syntax_t *syntax,
1584 int mb_x,
1585 int mb_y,
1586 short *blocks[6],
1587 unsigned char *bab,
1588 unsigned char *bab_map,
1589 fame_bab_t bab_type,
1590 int dquant,
1591 unsigned char pattern)
1592 {
1593 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1594 int coded[6];
1595 int i, j;
1596 int cbp, bc;
1597 short *a, *b, *c;
1598 short *p[6];
1599 short ys, cs, qs;
1600 short *d[6];
1601 short o[6];
1602 short ac_sad;
1603 unsigned char *zigzag[6];
1604 int retval;
1605
1606 p[0] = syntax_mpeg4->pred[0];
1607 p[1] = syntax_mpeg4->pred[1];
1608 p[2] = syntax_mpeg4->pred[2];
1609 p[3] = syntax_mpeg4->pred[3];
1610 p[4] = syntax_mpeg4->pred[4];
1611 p[5] = syntax_mpeg4->pred[5];
1612 d[0] = syntax_mpeg4->diff[0];
1613 d[1] = syntax_mpeg4->diff[1];
1614 d[2] = syntax_mpeg4->diff[2];
1615 d[3] = syntax_mpeg4->diff[3];
1616 d[4] = syntax_mpeg4->diff[4];
1617 d[5] = syntax_mpeg4->diff[5];
1618 o[0] = o[1] = o[3] = o[4] = o[4] = o[5] = TOP_PREDICTED;
1619 FASTCOPY16(p[0], syntax_mpeg4->pred_default);
1620 FASTCOPY16(p[2], syntax_mpeg4->pred_default);
1621 FASTCOPY16(p[1], syntax_mpeg4->pred_default);
1622 FASTCOPY16(p[3], syntax_mpeg4->pred_default);
1623 FASTCOPY16(p[4], syntax_mpeg4->pred_default);
1624 FASTCOPY16(p[5], syntax_mpeg4->pred_default);
1625
1626 if(syntax_mpeg4->video_object_layer_shape !=
1627 MPEG4_Video_Object_Layer_Shape_Rectangular)
1628 mpeg4_write_intra_bab(syntax, mb_x, mb_y, bab, bab_map, bab_type);
1629
1630 if(bab_type != bab_not_coded) { /* not transparent */
1631 if(syntax_mpeg4->vop_coding_type != MPEG4_I_FRAME)
1632 bitbuffer_write(&syntax_mpeg4->buffer, 0, 1);
1633
1634 syntax_mpeg4->quant_scale += dquant;
1635 qs = syntax_mpeg4->quant_scale;
1636 ys = syntax_mpeg4->y_dc_scaler[qs];
1637 cs = syntax_mpeg4->c_dc_scaler[qs];
1638
1639 /* prediction */
1640 if(!mb_x) { /* start of line, reset horizontal predictors */
1641 FASTCOPY16(syntax_mpeg4->y_pred_h[0], syntax_mpeg4->pred_default);
1642 FASTCOPY16(syntax_mpeg4->y_pred_h[1], syntax_mpeg4->pred_default);
1643 FASTCOPY16(syntax_mpeg4->y_pred_h[2], syntax_mpeg4->pred_default);
1644 FASTCOPY16(syntax_mpeg4->cb_pred_h[0], syntax_mpeg4->pred_default);
1645 FASTCOPY16(syntax_mpeg4->cb_pred_h[1], syntax_mpeg4->pred_default);
1646 FASTCOPY16(syntax_mpeg4->cr_pred_h[0], syntax_mpeg4->pred_default);
1647 FASTCOPY16(syntax_mpeg4->cr_pred_h[1], syntax_mpeg4->pred_default);
1648 }
1649
1650 ac_sad = 0;
1651
1652 /* Y (0,0) block */
1653 if(pattern & 1) {
1654 a = syntax_mpeg4->y_pred_h[1]; /* left block */
1655 b = syntax_mpeg4->y_pred_h[0]; /* top left block */
1656 c = syntax_mpeg4->y_pred_v[0][mb_x]; /* top block */
1657
1658 /* choose between vertical and horizontal prediction */
1659 if(abs(*a - *b) < abs(*b - *c)) {
1660 FASTAC8H(d[0], blocks[0]);
1661 FASTSCALE8H(p[0], c, qs);
1662 FASTSAD8H(ac_sad, p[0], d[0]);
1663 o[0] = TOP_PREDICTED;
1664 *p[0] = (*p[0] + (ys>>1)) / ys;
1665 FASTDIFF8H(d[0], p[0]);
1666 *d[0] = mpeg4_table_clip[*d[0]];
1667 FASTSUM8H(p[0], d[0]);
1668 *p[0] *= ys;
1669 } else {
1670 FASTAC8V(d[0], blocks[0]);
1671 FASTSCALE8V(p[0], a, qs);
1672 FASTSAD8V(ac_sad, p[0], d[0]);
1673 o[0] = LEFT_PREDICTED;
1674 *p[0] = (*p[0] + (ys>>1)) / ys;
1675 FASTDIFF8V(d[0], p[0]);
1676 *d[0] = mpeg4_table_clip[*d[0]];
1677 FASTSUM8V(p[0], d[0]);
1678 *p[0] *= ys;
1679 }
1680 p[0][FASTQS] = qs;
1681 }
1682
1683 /* Y (0,1) block */
1684 if(pattern & 2) {
1685 a = p[0]; /* left block */
1686 b = syntax_mpeg4->y_pred_v[0][mb_x]; /* top left block */
1687 c = syntax_mpeg4->y_pred_v[1][mb_x]; /* top block */
1688
1689 /* choose between vertical and horizontal prediction */
1690 if(abs(*a - *b) < abs(*b - *c)) {
1691 FASTAC8H(d[1], blocks[1]);
1692 FASTSCALE8H(p[1], c, qs);
1693 FASTSAD8H(ac_sad, p[1], d[1]);
1694 o[1] = TOP_PREDICTED;
1695 *p[1] = (*p[1] + (ys>>1)) / ys;
1696 FASTDIFF8H(d[1], p[1]);
1697 *d[1] = mpeg4_table_clip[*d[1]];
1698 FASTSUM8H(p[1], d[1]);
1699 *p[1] *= ys;
1700 } else {
1701 FASTAC8V(d[1], blocks[1]);
1702 FASTSCALE8V(p[1], a, qs);
1703 FASTSAD8V(ac_sad, p[1], d[1]);
1704 o[1] = LEFT_PREDICTED;
1705 *p[1] = (*p[1] + (ys>>1)) / ys;
1706 FASTDIFF8V(d[1], p[1]);
1707 *d[1] = mpeg4_table_clip[*d[1]];
1708 FASTSUM8V(p[1], d[1]);
1709 *p[1] *= ys;
1710 }
1711 p[1][FASTQS] = qs;
1712 }
1713
1714 /* Y (1,0) block */
1715 if(pattern & 4) {
1716 a = syntax_mpeg4->y_pred_h[2]; /* left block */
1717 b = syntax_mpeg4->y_pred_h[1]; /* top left block */
1718 c = p[0]; /* top block */
1719
1720 /* choose between vertical and horizontal prediction */
1721 if(abs(*a - *b) < abs(*b - *c)) {
1722 FASTAC8H(d[2], blocks[2]);
1723 FASTSCALE8H(p[2], c, qs);
1724 FASTSAD8H(ac_sad, p[2], d[2]);
1725 o[2] = TOP_PREDICTED;
1726 *p[2] = (*p[2] + (ys>>1)) / ys;
1727 FASTDIFF8H(d[2], p[2]);
1728 *d[2] = mpeg4_table_clip[*d[2]];
1729 FASTSUM8H(p[2], d[2]);
1730 *p[2] *= ys;
1731 } else {
1732 FASTAC8V(d[2], blocks[2]);
1733 FASTSCALE8V(p[2], a, qs);
1734 FASTSAD8V(ac_sad, p[2], d[2]);
1735 o[2] = LEFT_PREDICTED;
1736 *p[2] = (*p[2] + (ys>>1)) / ys;
1737 FASTDIFF8V(d[2], p[2]);
1738 *d[2] = mpeg4_table_clip[*d[2]];
1739 FASTSUM8V(p[2], d[2]);
1740 *p[2] *= ys;
1741 }
1742 p[2][FASTQS] = qs;
1743 }
1744
1745 /* Y (1,1) block */
1746 if(pattern & 8) {
1747 a = p[2]; /* left block */
1748 b = p[0]; /* top left block */
1749 c = p[1]; /* top block */
1750
1751 /* choose between vertical and horizontal prediction */
1752 if(abs(*a - *b) < abs(*b - *c)) {
1753 FASTAC8H(d[3], blocks[3]);
1754 FASTSCALE8H(p[3], c, qs);
1755 FASTSAD8H(ac_sad, p[3], d[3]);
1756 o[3] = TOP_PREDICTED;
1757 *p[3] = (*p[3] + (ys>>1)) / ys;
1758 FASTDIFF8H(d[3], p[3]);
1759 *d[3] = mpeg4_table_clip[*d[3]];
1760 FASTSUM8H(p[3], d[3]);
1761 *p[3] *= ys;
1762 } else {
1763 FASTAC8V(d[3], blocks[3]);
1764 FASTSCALE8V(p[3], a, qs);
1765 FASTSAD8V(ac_sad, p[3], d[3]);
1766 o[3] = LEFT_PREDICTED;
1767 *p[3] = (*p[3] + (ys>>1)) / ys;
1768 FASTDIFF8V(d[3], p[3]);
1769 *d[3] = mpeg4_table_clip[*d[3]];
1770 FASTSUM8V(p[3], d[3]);
1771 *p[3] *= ys;
1772 }
1773 p[3][FASTQS] = qs;
1774 }
1775
1776 /* Cb block */
1777 a = syntax_mpeg4->cb_pred_h[1]; /* left block */
1778 b = syntax_mpeg4->cb_pred_h[0]; /* top left block */
1779 c = syntax_mpeg4->cb_pred_v[mb_x]; /* top block */
1780
1781 /* choose between vertical and horizontal prediction */
1782 if(abs(*a - *b) < abs(*b - *c)) {
1783 FASTAC8H(d[4], blocks[4]);
1784 FASTSCALE8H(p[4], c, qs);
1785 FASTSAD8H(ac_sad, p[4], d[4]);
1786 o[4] = TOP_PREDICTED;
1787 *p[4] = (*p[4] + (cs>>1)) / cs;
1788 FASTDIFF8H(d[4], p[4]);
1789 *d[4] = mpeg4_table_clip[*d[4]];
1790 FASTSUM8H(p[4], d[4]);
1791 *p[4] *= cs;
1792 } else {
1793 FASTAC8V(d[4], blocks[4]);
1794 FASTSCALE8V(p[4], a, qs);
1795 FASTSAD8V(ac_sad, p[4], d[4]);
1796 o[4] = LEFT_PREDICTED;
1797 *p[4] = (*p[4] + (cs>>1)) / cs;
1798 FASTDIFF8V(d[4], p[4]);
1799 *d[4] = mpeg4_table_clip[*d[4]];
1800 FASTSUM8V(p[4], d[4]);
1801 *p[4] *= cs;
1802 }
1803 p[4][FASTQS] = qs;
1804
1805 /* Cr block */
1806 a = syntax_mpeg4->cr_pred_h[1]; /* left block */
1807 b = syntax_mpeg4->cr_pred_h[0]; /* top left block */
1808 c = syntax_mpeg4->cr_pred_v[mb_x]; /* top block */
1809
1810 /* choose between vertical and horizontal prediction */
1811 if(abs(*a - *b) < abs(*b - *c)) {
1812 FASTAC8H(d[5], blocks[5]);
1813 FASTSCALE8H(p[5], c, qs);
1814 FASTSAD8H(ac_sad, p[5], d[5]);
1815 o[5] = TOP_PREDICTED;
1816 *p[5] = (*p[5] + (cs>>1)) / cs;
1817 FASTDIFF8H(d[5], p[5]);
1818 *d[5] = mpeg4_table_clip[*d[5]];
1819 FASTSUM8H(p[5], d[5]);
1820 *p[5] *= cs;
1821 } else {
1822 FASTAC8V(d[5], blocks[5]);
1823 FASTSCALE8V(p[5], a, qs);
1824 FASTSAD8V(ac_sad, p[5], d[5]);
1825 o[5] = LEFT_PREDICTED;
1826 *p[5] = (*p[5] + (cs>>1)) / cs;
1827 FASTDIFF8V(d[5], p[5]);
1828 *d[5] = mpeg4_table_clip[*d[5]];
1829 FASTSUM8V(p[5], d[5]);
1830 *p[5] *= cs;
1831 }
1832 p[5][FASTQS] = qs;
1833
1834 /* AC/DC adjust blocks */
1835 if(ac_sad > 0) {
1836 for(i = 0; i < 6; i++) {
1837 if(o[i] == LEFT_PREDICTED) {
1838 zigzag[i] = mpeg4_zigzag_alternate_vertical_table;
1839 COPY8V(blocks[i], d[i]);
1840 } else {
1841 zigzag[i] = mpeg4_zigzag_alternate_horizontal_table;
1842 COPY8H(blocks[i], d[i]);
1843 }
1844 }
1845 } else {
1846 zigzag[0] =
1847 zigzag[1] =
1848 zigzag[2] =
1849 zigzag[3] =
1850 zigzag[4] =
1851 zigzag[5] = mpeg4_zigzag_table;
1852 }
1853
1854 /* check for not coded blocks */
1855 for(j = 0; j < 6; j++) {
1856 coded[j] = 0;
1857 for(i = 1; i < 64; i++) {
1858 coded[j] |= blocks[j][i];
1859 }
1860 }
1861
1862 /* write mcbpc */
1863 cbp = 0;
1864 if(coded[4]) cbp |= 2;
1865 if(coded[5]) cbp |= 1;
1866
1867 if(syntax_mpeg4->vop_coding_type == MPEG4_I_FRAME) {
1868 if(dquant) {
1869 bitbuffer_write(&syntax_mpeg4->buffer,
1870 mcbpc_I_dq[cbp].code, mcbpc_I_dq[cbp].length);
1871 } else {
1872 bitbuffer_write(&syntax_mpeg4->buffer,
1873 mcbpc_I[cbp].code, mcbpc_I[cbp].length);
1874 }
1875 } else {
1876 if(dquant) {
1877 bitbuffer_write(&syntax_mpeg4->buffer,
1878 mcbpc_P_intra_dq[cbp].code, mcbpc_P_intra_dq[cbp].length);
1879 } else {
1880 bitbuffer_write(&syntax_mpeg4->buffer,
1881 mcbpc_P_intra[cbp].code, mcbpc_P_intra[cbp].length);
1882 }
1883 }
1884
1885 /* AC pred flag */
1886 if(ac_sad > 0) {
1887 bitbuffer_write(&syntax_mpeg4->buffer, 1, 1);
1888 } else {
1889 bitbuffer_write(&syntax_mpeg4->buffer, 0, 1);
1890 }
1891
1892 /* write cbpy */
1893 bc = cbp = 0;
1894 for(i = 0; i < 4; i++) {
1895 if(pattern & (1<<i)) {
1896 bc++; /* number of non-transparent blocks */
1897 cbp <<= 1; /* coded block pattern */
1898 if(coded[i]) cbp |= 1;
1899 }
1900 }
1901 bitbuffer_write(&syntax_mpeg4->buffer,
1902 cbpy[bc-1][cbp].code,
1903 cbpy[bc-1][cbp].length);
1904
1905 /* write dquant */
1906 if(dquant) {
1907 static const int dquant_table[5] = { 1, 0, 0, 2, 3 };
1908
1909 bitbuffer_write(&syntax_mpeg4->buffer, dquant_table[dquant+2], 2);
1910 }
1911
1912 if(pattern & 1)
1913 mpeg4_block_intra(syntax,blocks[0],encode_ydc_table,*d[0],zigzag[0],coded[0]);
1914 if(pattern & 2)
1915 mpeg4_block_intra(syntax,blocks[1],encode_ydc_table,*d[1],zigzag[1],coded[1]);
1916 if(pattern & 4)
1917 mpeg4_block_intra(syntax,blocks[2],encode_ydc_table,*d[2],zigzag[2],coded[2]);
1918 if(pattern & 8)
1919 mpeg4_block_intra(syntax,blocks[3],encode_ydc_table,*d[3],zigzag[3],coded[3]);
1920 mpeg4_block_intra(syntax,blocks[4],encode_cdc_table,*d[4],zigzag[4],coded[4]);
1921 mpeg4_block_intra(syntax,blocks[5],encode_cdc_table,*d[5],zigzag[5],coded[5]);
1922
1923 if(ac_sad >= 0) {
1924 for(i = 0; i < 6; i++) {
1925 if(o[i] == LEFT_PREDICTED) {
1926 COPY8V(blocks[i], p[i]);
1927 }
1928 else {
1929 COPY8H(blocks[i], p[i]);
1930 }
1931 }
1932 }
1933 /* TODO: fill in predictors from block */
1934
1935 /* update predictors */
1936 FASTCOPY16(syntax_mpeg4->y_pred_h[0], syntax_mpeg4->y_pred_v[1][mb_x]);
1937 FASTCOPY16(syntax_mpeg4->y_pred_h[1], p[1]);
1938 FASTCOPY16(syntax_mpeg4->y_pred_h[2], p[3]);
1939 FASTCOPY16(syntax_mpeg4->y_pred_v[0][mb_x], p[2]);
1940 FASTCOPY16(syntax_mpeg4->y_pred_v[1][mb_x], syntax_mpeg4->y_pred_h[2]);
1941 FASTCOPY16(syntax_mpeg4->cb_pred_h[0], syntax_mpeg4->cb_pred_v[mb_x]);
1942 FASTCOPY16(syntax_mpeg4->cr_pred_h[0], syntax_mpeg4->cr_pred_v[mb_x]);
1943 FASTCOPY16(syntax_mpeg4->cb_pred_v[mb_x], p[4]);
1944 FASTCOPY16(syntax_mpeg4->cr_pred_v[mb_x], p[5]);
1945 FASTCOPY16(syntax_mpeg4->cb_pred_h[1], syntax_mpeg4->cb_pred_v[mb_x]);
1946 FASTCOPY16(syntax_mpeg4->cr_pred_h[1], syntax_mpeg4->cr_pred_v[mb_x]);
1947 /* mark all vectors as valid */
1948 syntax_mpeg4->mv_pred[0].count = 64;
1949 syntax_mpeg4->mv_pred[1].count = 64;
1950 syntax_mpeg4->mv_pred[2].count = 64;
1951 syntax_mpeg4->mv_pred[3].count = 64;
1952 retval = 0;
1953 } else {
1954 /* reset predictors */
1955 FASTCOPY16(syntax_mpeg4->y_pred_h[0], syntax_mpeg4->y_pred_v[1][mb_x]);
1956 FASTCOPY16(syntax_mpeg4->y_pred_h[1], syntax_mpeg4->pred_default);
1957 FASTCOPY16(syntax_mpeg4->y_pred_h[2], syntax_mpeg4->pred_default);
1958 FASTCOPY16(syntax_mpeg4->y_pred_v[0][mb_x], syntax_mpeg4->pred_default);
1959 FASTCOPY16(syntax_mpeg4->y_pred_v[1][mb_x], syntax_mpeg4->pred_default);
1960 FASTCOPY16(syntax_mpeg4->cb_pred_h[0], syntax_mpeg4->cb_pred_v[mb_x]);
1961 FASTCOPY16(syntax_mpeg4->cr_pred_h[0], syntax_mpeg4->cr_pred_v[mb_x]);
1962 FASTCOPY16(syntax_mpeg4->cb_pred_v[mb_x], syntax_mpeg4->pred_default);
1963 FASTCOPY16(syntax_mpeg4->cr_pred_v[mb_x], syntax_mpeg4->pred_default);
1964 FASTCOPY16(syntax_mpeg4->cb_pred_h[1], syntax_mpeg4->pred_default);
1965 FASTCOPY16(syntax_mpeg4->cr_pred_h[1], syntax_mpeg4->pred_default);
1966 syntax_mpeg4->mv_pred[0].count = 0;
1967 syntax_mpeg4->mv_pred[1].count = 0;
1968 syntax_mpeg4->mv_pred[2].count = 0;
1969 syntax_mpeg4->mv_pred[3].count = 0;
1970 retval = dquant; /* cancel dquant */
1971 }
1972 /* reset motion predictors */
1973 syntax_mpeg4->mv_pred[0].dx = syntax_mpeg4->mv_pred[0].dy = 0;
1974 syntax_mpeg4->mv_pred[1].dx = syntax_mpeg4->mv_pred[1].dy = 0;
1975 syntax_mpeg4->mv_pred[2].dx = syntax_mpeg4->mv_pred[2].dy = 0;
1976 syntax_mpeg4->mv_pred[3].dx = syntax_mpeg4->mv_pred[3].dy = 0;
1977 syntax_mpeg4->mv_pred+=4;
1978
1979 return(retval);
1980 }
1981
mpeg4_block_inter(fame_syntax_t * syntax,short * block)1982 static void mpeg4_block_inter(fame_syntax_t *syntax, short *block)
1983 {
1984 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
1985 short i, v;
1986 unsigned long last;
1987 fame_vlc_t const *vlc;
1988 fame_bitbuffer_t * const buffer = &syntax_mpeg4->buffer;
1989 unsigned char * data = buffer->data;
1990 unsigned long shift = buffer->shift;
1991
1992 i = 0;
1993 last = 0;
1994
1995 /* i < 64 checking not needed as all-zero block is not coded */
1996 while((v = block[mpeg4_zigzag_table[i]]) == 0) i++;
1997
1998 do {
1999 /* count zeroes */
2000 vlc = syntax_mpeg4->inter_table +
2001 (mpeg4_table_clip[v] << 6) +
2002 i - last;
2003 last = ++i;
2004 while(i < 64 && (v = block[mpeg4_zigzag_table[i]]) == 0) i++;
2005
2006 /* write code */
2007 if(i != 64) {
2008 fast_bitbuffer_write(data, shift, vlc->code, vlc->length);
2009 } else {
2010 vlc += 64*511;
2011 fast_bitbuffer_write(data, shift, vlc->code, vlc->length);
2012 break;
2013 }
2014 } while(1);
2015
2016 buffer->data = data;
2017 buffer->shift = shift;
2018 }
2019
mpeg4_write_vector(fame_syntax_t * syntax,short delta)2020 static void inline mpeg4_write_vector(fame_syntax_t *syntax, short delta)
2021 {
2022 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
2023
2024 /* vectors are in half-sample units */
2025 if (delta == 0) {
2026 bitbuffer_write(&syntax_mpeg4->buffer,
2027 mb_motion_table[32].code,
2028 mb_motion_table[32].length);
2029 } else {
2030 short length;
2031 short f_code;
2032 short code;
2033 short residual;
2034
2035 f_code = syntax_mpeg4->vop_fcode_forward;
2036
2037 length = 16 << f_code;
2038 f_code--;
2039
2040 if(delta >= length)
2041 delta = delta - length - length;
2042
2043 if(delta < -length)
2044 delta = delta + length + length;
2045
2046 if(delta > 0) {
2047 delta--;
2048 residual = delta & ((1 << f_code) - 1);
2049 code = ((delta - residual) >> f_code) + 1;
2050 } else {
2051 delta = -delta;
2052 delta--;
2053 residual = delta & ((1 << f_code) - 1);
2054 code = ((delta - residual) >> f_code) + 1;
2055 code = -code;
2056 }
2057
2058 code += 32;
2059 bitbuffer_write(&syntax_mpeg4->buffer,
2060 mb_motion_table[code].code,
2061 mb_motion_table[code].length);
2062
2063 if(f_code)
2064 bitbuffer_write(&syntax_mpeg4->buffer, residual, f_code);
2065 }
2066 }
2067
mpeg4_write_inter_mb(fame_syntax_t * syntax,int mb_x,int mb_y,short * blocks[6],unsigned char * bab,unsigned char * bab_map,fame_bab_t bab_type,int dquant,unsigned char pattern,fame_motion_vector_t * forward,fame_motion_vector_t * backward,fame_motion_coding_t motion_coding)2068 static int mpeg4_write_inter_mb(fame_syntax_t *syntax,
2069 int mb_x,
2070 int mb_y,
2071 short *blocks[6],
2072 unsigned char *bab,
2073 unsigned char *bab_map,
2074 fame_bab_t bab_type,
2075 int dquant,
2076 unsigned char pattern,
2077 fame_motion_vector_t *forward,
2078 fame_motion_vector_t *backward,
2079 fame_motion_coding_t motion_coding)
2080 {
2081 fame_syntax_mpeg4_t *syntax_mpeg4 = FAME_SYNTAX_MPEG4(syntax);
2082 int coded[6];
2083 int i, j;
2084 int cbp, bc;
2085 int retval;
2086
2087 if(syntax_mpeg4->video_object_layer_shape !=
2088 MPEG4_Video_Object_Layer_Shape_Rectangular)
2089 mpeg4_write_intra_bab(syntax, mb_x, mb_y, bab, bab_map, bab_type);
2090
2091 if(bab_type != bab_not_coded) { /* not transparent */
2092
2093 /* check for not coded blocks */
2094 for(j = 0; j < 6; j++) {
2095 coded[j] = 0;
2096 if(blocks[j] != NULL)
2097 for(i = 0; i < 64; i++) {
2098 coded[j] |= blocks[j][i];
2099 }
2100 }
2101
2102 if(/* TODO: check slice start/end ?*/
2103 motion_coding != motion_inter4v &&
2104 forward[0].dx == 0 &&
2105 forward[0].dy == 0 &&
2106 !((coded[0] && (pattern & 1)) ||
2107 (coded[1] && (pattern & 2)) ||
2108 (coded[2] && (pattern & 4)) ||
2109 (coded[3] && (pattern & 8)) ||
2110 coded[4] ||
2111 coded[5] ))
2112 {
2113 bitbuffer_write(&syntax_mpeg4->buffer, 1, 1); /* skip */
2114 /* reset motion predictors */
2115 syntax_mpeg4->mv_pred[0].dx = syntax_mpeg4->mv_pred[0].dy = 0;
2116 syntax_mpeg4->mv_pred[1].dx = syntax_mpeg4->mv_pred[1].dy = 0;
2117 syntax_mpeg4->mv_pred[2].dx = syntax_mpeg4->mv_pred[2].dy = 0;
2118 syntax_mpeg4->mv_pred[3].dx = syntax_mpeg4->mv_pred[3].dy = 0;
2119 syntax_mpeg4->mv_pred[0].count = 64; /*mark as valid*/
2120 syntax_mpeg4->mv_pred[1].count = 64; /*mark as valid*/
2121 syntax_mpeg4->mv_pred[2].count = 64; /*mark as valid*/
2122 syntax_mpeg4->mv_pred[3].count = 64; /*mark as valid*/
2123 /* reset AC/DC predictors */
2124 FASTCOPY16(syntax_mpeg4->y_pred_h[0], syntax_mpeg4->y_pred_v[1][mb_x]);
2125 FASTCOPY16(syntax_mpeg4->y_pred_h[1], syntax_mpeg4->pred_default);
2126 FASTCOPY16(syntax_mpeg4->y_pred_h[2], syntax_mpeg4->pred_default);
2127 FASTCOPY16(syntax_mpeg4->y_pred_v[0][mb_x], syntax_mpeg4->pred_default);
2128 FASTCOPY16(syntax_mpeg4->y_pred_v[1][mb_x], syntax_mpeg4->pred_default);
2129 FASTCOPY16(syntax_mpeg4->cb_pred_h[0], syntax_mpeg4->cb_pred_v[mb_x]);
2130 FASTCOPY16(syntax_mpeg4->cr_pred_h[0], syntax_mpeg4->cr_pred_v[mb_x]);
2131 FASTCOPY16(syntax_mpeg4->cb_pred_v[mb_x], syntax_mpeg4->pred_default);
2132 FASTCOPY16(syntax_mpeg4->cr_pred_v[mb_x], syntax_mpeg4->pred_default);
2133 FASTCOPY16(syntax_mpeg4->cb_pred_h[1], syntax_mpeg4->pred_default);
2134 FASTCOPY16(syntax_mpeg4->cr_pred_h[1], syntax_mpeg4->pred_default);
2135 syntax_mpeg4->mv_pred+=4;
2136 /* skipped macroblock */
2137 return(dquant);
2138 } else {
2139 bitbuffer_write(&syntax_mpeg4->buffer, 0, 1);
2140 }
2141
2142
2143 /* write mcbpc */
2144 cbp = 0;
2145 if(coded[4]) cbp |= 2;
2146 if(coded[5]) cbp |= 1;
2147
2148 if(motion_coding == motion_inter4v) {
2149 bitbuffer_write(&syntax_mpeg4->buffer,
2150 mcbpc_P_inter4v[cbp].code, mcbpc_P_inter4v[cbp].length);
2151 } else {
2152 if(dquant) {
2153 bitbuffer_write(&syntax_mpeg4->buffer,
2154 mcbpc_P_inter_dq[cbp].code, mcbpc_P_inter_dq[cbp].length);
2155 } else {
2156 bitbuffer_write(&syntax_mpeg4->buffer,
2157 mcbpc_P_inter[cbp].code, mcbpc_P_inter[cbp].length);
2158 }
2159 }
2160 /* write cbpy */
2161 bc = cbp = 0;
2162 for(i = 0; i < 4; i++) {
2163 if(pattern & (1<<i)) {
2164 bc++; /* number of non-transparent blocks */
2165 cbp <<= 1; /* coded block pattern */
2166 if(coded[i]) cbp |= 1;
2167 }
2168 }
2169
2170 cbp = (1 << bc) - 1 - cbp; /* inter code the same as intra code for inverse pattern */
2171 bitbuffer_write(&syntax_mpeg4->buffer,
2172 cbpy[bc-1][cbp].code,
2173 cbpy[bc-1][cbp].length);
2174
2175 /* write dquant */
2176 if(motion_coding != motion_inter4v && dquant) {
2177 static const int dquant_table[5] = { 1, 0, 0, 2, 3 };
2178
2179 bitbuffer_write(&syntax_mpeg4->buffer, dquant_table[dquant+2], 2);
2180 syntax_mpeg4->quant_scale += dquant;
2181 retval = 0;
2182 } else {
2183 retval = dquant;
2184 }
2185
2186 /* motion vector forward */
2187
2188 if(motion_coding == motion_inter4v) {
2189 /* number of vectors depends on shape */
2190 if(pattern & 1) {
2191 mpeg4_write_vector(syntax, forward[0].dx-syntax_mpeg4->mv_pred[0].dx);
2192 mpeg4_write_vector(syntax, forward[0].dy-syntax_mpeg4->mv_pred[0].dy);
2193 }
2194 if(pattern & 2) {
2195 syntax->predict_vector(syntax, mb_x, mb_y, 1, forward);
2196 mpeg4_write_vector(syntax, forward[1].dx-syntax_mpeg4->mv_pred[1].dx);
2197 mpeg4_write_vector(syntax, forward[1].dy-syntax_mpeg4->mv_pred[1].dy);
2198 }
2199 if(pattern & 4) {
2200 syntax->predict_vector(syntax, mb_x, mb_y, 2, forward);
2201 mpeg4_write_vector(syntax, forward[2].dx-syntax_mpeg4->mv_pred[2].dx);
2202 mpeg4_write_vector(syntax, forward[2].dy-syntax_mpeg4->mv_pred[2].dy);
2203 }
2204 if(pattern & 8) {
2205 syntax->predict_vector(syntax, mb_x, mb_y, 3, forward);
2206 mpeg4_write_vector(syntax, forward[3].dx-syntax_mpeg4->mv_pred[3].dx);
2207 mpeg4_write_vector(syntax, forward[3].dy-syntax_mpeg4->mv_pred[3].dy);
2208 }
2209 } else {
2210 mpeg4_write_vector(syntax, forward[0].dx-syntax_mpeg4->mv_pred[0].dx);
2211 mpeg4_write_vector(syntax, forward[0].dy-syntax_mpeg4->mv_pred[0].dy);
2212 }
2213
2214 /* Y (0,0) block */
2215 if((pattern & 1) && coded[0])
2216 mpeg4_block_inter(syntax, blocks[0]);
2217
2218 /* Y (0,1) block */
2219 if((pattern & 2) && coded[1])
2220 mpeg4_block_inter(syntax, blocks[1]);
2221
2222 /* Y (1,0) block */
2223 if((pattern & 4) && coded[2])
2224 mpeg4_block_inter(syntax, blocks[2]);
2225
2226 /* Y (1,1) block */
2227 if((pattern & 8) && coded[3])
2228 mpeg4_block_inter(syntax, blocks[3]);
2229
2230 /* Cb block */
2231 if(coded[4])
2232 mpeg4_block_inter(syntax, blocks[4]);
2233
2234 /* Cr block */
2235 if(coded[5])
2236 mpeg4_block_inter(syntax, blocks[5]);
2237
2238 if(motion_coding == motion_inter4v) {
2239 /* pad motion vectors */
2240 switch(pattern) {
2241 /* 10 */
2242 /* 00 */
2243 case 0x1:
2244 forward[1].dx = forward[0].dx;
2245 forward[1].dy = forward[0].dy;
2246 forward[2].dx = forward[0].dx;
2247 forward[2].dy = forward[0].dy;
2248 forward[3].dx = forward[0].dx;
2249 forward[3].dy = forward[0].dy;
2250 break;
2251 /* 01 */
2252 /* 00 */
2253 case 0x2:
2254 forward[0].dx = forward[1].dx;
2255 forward[0].dy = forward[1].dy;
2256 forward[2].dx = forward[1].dx;
2257 forward[2].dy = forward[1].dy;
2258 forward[3].dx = forward[1].dx;
2259 forward[3].dy = forward[1].dy;
2260 break;
2261 /* 11 */
2262 /* 00 */
2263 case 0x3:
2264 forward[2].dx = forward[0].dx;
2265 forward[2].dy = forward[0].dy;
2266 forward[3].dx = forward[1].dx;
2267 forward[3].dy = forward[1].dy;
2268 break;
2269 /* 00 */
2270 /* 10 */
2271 case 0x4:
2272 forward[0].dx = forward[2].dx;
2273 forward[0].dy = forward[2].dy;
2274 forward[1].dx = forward[2].dx;
2275 forward[1].dy = forward[2].dy;
2276 forward[3].dx = forward[2].dx;
2277 forward[3].dy = forward[2].dy;
2278 break;
2279 /* 10 */
2280 /* 10 */
2281 case 0x5:
2282 forward[1].dx = forward[0].dx;
2283 forward[1].dy = forward[0].dy;
2284 forward[3].dx = forward[2].dx;
2285 forward[3].dy = forward[2].dy;
2286 break;
2287 /* 01 */
2288 /* 10 */
2289 case 0x6:
2290 forward[0].dx = forward[1].dx;
2291 forward[0].dy = forward[1].dy;
2292 forward[3].dx = forward[2].dx;
2293 forward[3].dy = forward[2].dy;
2294 break;
2295 /* 11 */
2296 /* 10 */
2297 case 0x7:
2298 forward[3].dx = forward[2].dx;
2299 forward[3].dy = forward[2].dy;
2300 break;
2301 /* 00 */
2302 /* 01 */
2303 case 0x8:
2304 forward[0].dx = forward[3].dx;
2305 forward[0].dy = forward[3].dy;
2306 forward[1].dx = forward[3].dx;
2307 forward[1].dy = forward[3].dy;
2308 forward[2].dx = forward[3].dx;
2309 forward[2].dy = forward[3].dy;
2310 break;
2311 /* 10 */
2312 /* 01 */
2313 case 0x9:
2314 forward[1].dx = forward[0].dx;
2315 forward[1].dy = forward[0].dy;
2316 forward[2].dx = forward[3].dx;
2317 forward[2].dy = forward[3].dy;
2318 break;
2319 /* 01 */
2320 /* 01 */
2321 case 0xa:
2322 forward[0].dx = forward[1].dx;
2323 forward[0].dy = forward[1].dy;
2324 forward[2].dx = forward[3].dx;
2325 forward[2].dy = forward[3].dy;
2326 break;
2327 /* 11 */
2328 /* 01 */
2329 case 0xb:
2330 forward[2].dx = forward[3].dx;
2331 forward[2].dy = forward[3].dy;
2332 break;
2333 /* 00 */
2334 /* 11 */
2335 case 0xc:
2336 forward[0].dx = forward[2].dx;
2337 forward[0].dy = forward[2].dy;
2338 forward[1].dx = forward[3].dx;
2339 forward[1].dy = forward[3].dy;
2340 break;
2341 /* 10 */
2342 /* 11 */
2343 case 0xd:
2344 forward[1].dx = forward[0].dx;
2345 forward[1].dy = forward[0].dy;
2346 break;
2347 /* 01 */
2348 /* 11 */
2349 case 0xe:
2350 forward[0].dx = forward[1].dx;
2351 forward[0].dy = forward[1].dy;
2352 break;
2353 }
2354 syntax_mpeg4->mv_pred[0].count = 64; /* valid */
2355 syntax_mpeg4->mv_pred[1].count = 64; /* valid */
2356 syntax_mpeg4->mv_pred[2].count = 64; /* valid */
2357 syntax_mpeg4->mv_pred[3].count = 64; /* valid */
2358 } else {
2359 /* mark all vectors as valid */
2360 syntax_mpeg4->mv_pred[0].count = 64;
2361 syntax_mpeg4->mv_pred[1].count = 64;
2362 syntax_mpeg4->mv_pred[2].count = 64;
2363 syntax_mpeg4->mv_pred[3].count = 64;
2364 }
2365
2366 /* update motion prediction */
2367 syntax_mpeg4->mv_pred[0].dx = forward[0].dx;
2368 syntax_mpeg4->mv_pred[0].dy = forward[0].dy;
2369 syntax_mpeg4->mv_pred[1].dx = forward[1].dx;
2370 syntax_mpeg4->mv_pred[1].dy = forward[1].dy;
2371 syntax_mpeg4->mv_pred[2].dx = forward[2].dx;
2372 syntax_mpeg4->mv_pred[2].dy = forward[2].dy;
2373 syntax_mpeg4->mv_pred[3].dx = forward[3].dx;
2374 syntax_mpeg4->mv_pred[3].dy = forward[3].dy;
2375 } else {
2376 /* reset motion predictors */
2377 syntax_mpeg4->mv_pred[0].dx = syntax_mpeg4->mv_pred[0].dy = 0;
2378 syntax_mpeg4->mv_pred[1].dx = syntax_mpeg4->mv_pred[1].dy = 0;
2379 syntax_mpeg4->mv_pred[2].dx = syntax_mpeg4->mv_pred[2].dy = 0;
2380 syntax_mpeg4->mv_pred[3].dx = syntax_mpeg4->mv_pred[3].dy = 0;
2381 syntax_mpeg4->mv_pred[0].count = 0;
2382 syntax_mpeg4->mv_pred[1].count = 0;
2383 syntax_mpeg4->mv_pred[2].count = 0;
2384 syntax_mpeg4->mv_pred[3].count = 0;
2385 retval = dquant; /* cancel dquant */
2386 }
2387 /* reset AC/DC predictors */
2388 FASTCOPY16(syntax_mpeg4->y_pred_h[0], syntax_mpeg4->y_pred_v[1][mb_x]);
2389 FASTCOPY16(syntax_mpeg4->y_pred_h[1], syntax_mpeg4->pred_default);
2390 FASTCOPY16(syntax_mpeg4->y_pred_h[2], syntax_mpeg4->pred_default);
2391 FASTCOPY16(syntax_mpeg4->y_pred_v[0][mb_x], syntax_mpeg4->pred_default);
2392 FASTCOPY16(syntax_mpeg4->y_pred_v[1][mb_x], syntax_mpeg4->pred_default);
2393 FASTCOPY16(syntax_mpeg4->cb_pred_h[0], syntax_mpeg4->cb_pred_v[mb_x]);
2394 FASTCOPY16(syntax_mpeg4->cr_pred_h[0], syntax_mpeg4->cr_pred_v[mb_x]);
2395 FASTCOPY16(syntax_mpeg4->cb_pred_v[mb_x], syntax_mpeg4->pred_default);
2396 FASTCOPY16(syntax_mpeg4->cr_pred_v[mb_x], syntax_mpeg4->pred_default);
2397 FASTCOPY16(syntax_mpeg4->cb_pred_h[1], syntax_mpeg4->pred_default);
2398 FASTCOPY16(syntax_mpeg4->cr_pred_h[1], syntax_mpeg4->pred_default);
2399
2400 syntax_mpeg4->mv_pred+=4;
2401
2402 return(retval);
2403 }
2404
mpeg4_compute_chrominance_vectors(fame_syntax_t * syntax,fame_motion_vector_t * vectors,unsigned char pattern)2405 static void mpeg4_compute_chrominance_vectors(fame_syntax_t *syntax,
2406 fame_motion_vector_t *vectors,
2407 unsigned char pattern)
2408 {
2409 int x, y, k;
2410 static int const rounding_16[16] = {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
2411 static int const rounding_12[12] = { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2};
2412 static int const rounding_8[8] = {0, 0, 1, 1, 1, 1, 1, 2 };
2413 static int const rounding_4[4] = {0, 1, 1, 1 };
2414
2415 /* rounding depends on shape */
2416 x = 0; y = 0; k = 0;
2417 if(pattern & 1) { x += vectors[0].dx; y += vectors[0].dy; k++; }
2418 if(pattern & 2) { x += vectors[1].dx; y += vectors[1].dy; k++; }
2419 if(pattern & 4) { x += vectors[2].dx; y += vectors[2].dy; k++; }
2420 if(pattern & 8) { x += vectors[3].dx; y += vectors[3].dy; k++; }
2421
2422 switch(k) {
2423 case 1:
2424 if(x > 0) vectors[4].dx = ((x >> 2) << 1) + rounding_4[x & 3];
2425 else vectors[4].dx = -((((-x) >> 2) << 1) + rounding_4[(-x) & 3]);
2426 if(y > 0) vectors[4].dy = ((y >> 2) << 1) + rounding_4[y & 3];
2427 else vectors[4].dy = -((((-y) >> 2) << 1) + rounding_4[(-y) & 3]);
2428 break;
2429 case 2:
2430 if(x > 0) vectors[4].dx = ((x >> 3) << 1) + rounding_8[x & 7];
2431 else vectors[4].dx = -((((-x) >> 3) << 1) + rounding_8[(-x) & 7]);
2432 if(y > 0) vectors[4].dy = ((y >> 3) << 1) + rounding_8[y & 7];
2433 else vectors[4].dy = -((((-y) >> 3) << 1) + rounding_8[(-y) & 7]);
2434 break;
2435 case 3:
2436 if(x > 0) vectors[4].dx = ((x / 12) << 1) + rounding_12[x % 12];
2437 else vectors[4].dx = -((((-x) / 12) << 1) + rounding_12[(-x) % 12]);
2438 if(y > 0) vectors[4].dy = ((y / 12) << 1) + rounding_12[y % 12];
2439 else vectors[4].dy = -((((-y) / 12) << 1) + rounding_12[(-y) % 12]);
2440 break;
2441 case 4:
2442 if(x > 0) vectors[4].dx = ((x >> 4) << 1) + rounding_16[x & 15];
2443 else vectors[4].dx = -((((-x) >> 4) << 1) + rounding_16[(-x) & 15]);
2444 if(y > 0) vectors[4].dy = ((y >> 4) << 1) + rounding_16[y & 15];
2445 else vectors[4].dy = -((((-y) >> 4) << 1) + rounding_16[(-y) & 15]);
2446 break;
2447 }
2448 vectors[5].dx = vectors[4].dx;
2449 vectors[5].dy = vectors[4].dy;
2450 }
2451