?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r499: This commit was manufactured by cvs2svn to create tag 'r1_2_1-last'.
[cinelerra_cv/mob.git] / hvirtual / quicktime / mpeg4.c
blobfe109c519b71f17d2620717ccc6ffc72958370e7
1 /* General codec for all MPEG-4 derived encoding. */
2 /* Uses ffmpeg and encore50. */
3 /* Encore50 still seemed to provide better results than ffmpeg for encoding */
4 /* so it does all the generic MPEG-4 encoding. */
5
6
7
8
9
10 #include <ffmpeg/avcodec.h>
11 #include "colormodels.h"
12 #include "funcprotos.h"
13 #include "quicktime.h"
14 #include "workarounds.h"
15 #include ENCORE_INCLUDE
16 //#include DECORE_INCLUDE
17
18
19
20 #include <pthread.h>
21 #include <stdint.h>
22 #include <stdlib.h>
23
24 #define FRAME_RATE_BASE 10000
25
26
27 typedef struct
28 {
29 #define FIELDS 2
30 int decode_initialized[FIELDS];
31
32
33 // FFMpeg internals
34 AVCodec *decoder[FIELDS];
35 AVCodecContext *decoder_context[FIELDS];
36 AVFrame picture[FIELDS];
37
38
39 // Decore internals
40 // DEC_PARAM dec_param[FIELDS];
41 // int decode_handle[FIELDS];
42
43 // Last frame decoded
44 long last_frame[FIELDS];
45
46 int got_key[FIELDS];
47
48
49
50
51
52
53
54
55
56
57 int encode_initialized[FIELDS];
58 // Information for picking the right library routines.
59 // ID out of avcodec.h for the codec used.
60 // Invalid if encore50 is used.
61 int ffmpeg_id;
62 // True if encore50 is being used.
63 int use_encore;
64
65 // FFMpeg internals
66 AVCodec *encoder[FIELDS];
67 AVCodecContext *encoder_context[FIELDS];
68
69
70 // Encore internals
71 int encode_handle[FIELDS];
72 ENC_PARAM enc_param[FIELDS];
73 // Must count pframes in VBR
74 int p_count[FIELDS];
75
76
77 // Encoding parameters
78 int bitrate;
79 // For heroine 60 encoding, we want different streams for each field.
80 int total_fields;
81 long rc_period; // the intended rate control averaging period
82 long rc_reaction_period; // the reation period for rate control
83 long rc_reaction_ratio; // the ratio for down/up rate control
84 long max_key_interval; // the maximum interval between key frames
85 int bitrate_tolerance;
86 int interlaced;
87 int gop_size;
88 int max_quantizer; // the upper limit of the quantizer
89 int min_quantizer; // the lower limit of the quantizer
90 int quantizer; // For vbr
91 int quality; // the forward search range for motion estimation
92 int fix_bitrate;
93 int use_deblocking;
94
95
96 // Temporary storage for color conversions
97 char *temp_frame;
98 // Storage of compressed data
99 unsigned char *work_buffer;
100 // Allocation of work_buffer
101 int buffer_size;
102 } quicktime_mpeg4_codec_t;
103
104 int ffmpeg_initialized = 0;
105 pthread_mutex_t ffmpeg_lock = PTHREAD_MUTEX_INITIALIZER;
106
107
108 // Decore needs the user to specify handles
109 static int decode_handle = 1;
110 static int encode_handle = 0;
111
112
113
114
115
116
117
118
119
120 // Utilities for programs wishing to parse MPEG-4
121
122
123 // Determine of the compressed frame is a keyframe for direct copy
124 int quicktime_mpeg4_is_key(unsigned char *data, long size, char *codec_id)
125 {
126 int result = 0;
127 int i;
128
129 if(quicktime_match_32(codec_id, QUICKTIME_DIVX) ||
130 quicktime_match_32(codec_id, QUICKTIME_HV60))
131 {
132 for(i = 0; i < size - 5; i++)
133 {
134 if( data[i] == 0x00 &&
135 data[i + 1] == 0x00 &&
136 data[i + 2] == 0x01 &&
137 data[i + 3] == 0xb6)
138 {
139 if((data[i + 4] & 0xc0) == 0x0)
140 return 1;
141 else
142 return 0;
143 }
144 }
145 }
146 return result;
147 }
148
149
150 // Test for VOL header in frame
151 int quicktime_mpeg4_has_vol(unsigned char *data)
152 {
153 if( data[0] == 0x00 &&
154 data[1] == 0x00 &&
155 data[2] == 0x01 &&
156 data[3] == 0x00 &&
157 data[4] == 0x00 &&
158 data[5] == 0x00 &&
159 data[6] == 0x01 &&
160 data[7] == 0x20)
161 return 1;
162 else
163 return 0;
164 }
165
166
167
168
169 static void putbits(unsigned char **data,
170 int *bit_pos,
171 uint64_t *bit_store,
172 int *total,
173 int count,
174 uint64_t value)
175 {
176 value &= 0xffffffffffffffffLL >> (64 - count);
177
178 while(64 - *bit_pos < count)
179 {
180 *(*data)++ = (*bit_store) >> 56;
181 (*bit_store) <<= 8;
182 (*bit_pos) -= 8;
183 }
184
185 (*bit_store) |= value << (64 - count - *bit_pos);
186 (*bit_pos) += count;
187 (*total) += count;
188 }
189
190
191 static void flushbits(unsigned char **data,
192 int *bit_pos,
193 uint64_t *bit_store)
194 {
195 //printf("flushbits %llx\n", (*bit_store));
196 while((*bit_pos) > 0)
197 {
198 *(*data)++ = (*bit_store) >> 56;
199 (*bit_store) <<= 8;
200 (*bit_pos) -= 8;
201 }
202 }
203
204
205
206
207 #define VO_START_CODE 0x8
208 #define VO_START_CODE_LENGTH 27
209 #define VOL_START_CODE 0x12 /* 25-MAR-97 JDL : according to WD2 */
210 #define VOL_START_CODE_LENGTH 28
211
212
213
214 int quicktime_mpeg4_write_vol(unsigned char *data_start,
215 int vol_width,
216 int vol_height,
217 int time_increment_resolution,
218 double frame_rate)
219 {
220 int written = 0;
221 int bits, fixed_vop_time_increment;
222 unsigned char *data = data_start;
223 int bit_pos;
224 uint64_t bit_store;
225 int i, j;
226
227 bit_store = 0;
228 bit_pos = 0;
229 vol_width = (int)((float)vol_width / 16 + 0.5) * 16;
230 vol_height = (int)((float)vol_height / 16 + 0.5) * 16;
231
232
233 putbits(&data,
234 &bit_pos,
235 &bit_store,
236 &written,
237 VO_START_CODE_LENGTH, VO_START_CODE);
238 putbits(&data,
239 &bit_pos,
240 &bit_store,
241 &written,
242 5, 0); /* vo_id = 0 */
243
244 putbits(&data,
245 &bit_pos,
246 &bit_store,
247 &written,
248 VOL_START_CODE_LENGTH, VOL_START_CODE);
249
250
251
252
253 putbits(&data,
254 &bit_pos,
255 &bit_store,
256 &written,
257 4, 0); /* vol_id = 0 */
258
259 putbits(&data,
260 &bit_pos,
261 &bit_store,
262 &written,
263 1, 0); /* random_accessible_vol = 0 */
264 putbits(&data,
265 &bit_pos,
266 &bit_store,
267 &written,
268 8, 1); /* video_object_type_indication = 1 video */
269 putbits(&data,
270 &bit_pos,
271 &bit_store,
272 &written,
273 1, 1); /* is_object_layer_identifier = 1 */
274 putbits(&data,
275 &bit_pos,
276 &bit_store,
277 &written,
278 4, 2); /* visual_object_layer_ver_id = 2 */
279 putbits(&data,
280 &bit_pos,
281 &bit_store,
282 &written,
283 3, 1); /* visual_object_layer_priority = 1 */
284 putbits(&data,
285 &bit_pos,
286 &bit_store,
287 &written,
288 4, 1); /* aspect_ratio_info = 1 */
289
290
291
292
293
294
295
296 putbits(&data,
297 &bit_pos,
298 &bit_store,
299 &written,
300 1, 0); /* vol_control_parameter = 0 */
301 putbits(&data,
302 &bit_pos,
303 &bit_store,
304 &written,
305 2, 0); /* vol_shape = 0 rectangular */
306 putbits(&data,
307 &bit_pos,
308 &bit_store,
309 &written,
310 1, 1); /* marker */
311
312
313
314
315
316
317
318 putbits(&data,
319 &bit_pos,
320 &bit_store,
321 &written,
322 16, time_increment_resolution);
323 putbits(&data,
324 &bit_pos,
325 &bit_store,
326 &written,
327 1, 1); /* marker */
328 putbits(&data,
329 &bit_pos,
330 &bit_store,
331 &written,
332 1, 1); /* fixed_vop_rate = 1 */
333
334
335 bits = 1;
336 while((1 << bits) < time_increment_resolution) bits++;
337
338 // Log calculation fails for some reason
339 // bits = (int)ceil(log((double)time_increment_resolution) / log(2.0));
340 // if (bits < 1) bits=1;
341
342 fixed_vop_time_increment =
343 (int)(time_increment_resolution / frame_rate + 0.1);
344
345 putbits(&data,
346 &bit_pos,
347 &bit_store,
348 &written,
349 bits, fixed_vop_time_increment);
350
351 putbits(&data,
352 &bit_pos,
353 &bit_store,
354 &written,
355 1, 1); /* marker */
356
357 putbits(&data,
358 &bit_pos,
359 &bit_store,
360 &written,
361 13, vol_width);
362 putbits(&data,
363 &bit_pos,
364 &bit_store,
365 &written,
366 1, 1); /* marker */
367 putbits(&data,
368 &bit_pos,
369 &bit_store,
370 &written,
371 13, vol_height);
372 putbits(&data,
373 &bit_pos,
374 &bit_store,
375 &written,
376 1, 1); /* marker */
377
378 putbits(&data,
379 &bit_pos,
380 &bit_store,
381 &written,
382 1, 0); /* interlaced = 0 */
383 putbits(&data,
384 &bit_pos,
385 &bit_store,
386 &written,
387 1, 1); /* OBMC_disabled = 1 */
388 putbits(&data,
389 &bit_pos,
390 &bit_store,
391 &written,
392 2, 0); /* vol_sprite_usage = 0 */
393 putbits(&data,
394 &bit_pos,
395 &bit_store,
396 &written,
397 1, 0); /* not_8_bit = 0 */
398
399 putbits(&data,
400 &bit_pos,
401 &bit_store,
402 &written,
403 1, 0); /* vol_quant_type = 0 */
404 putbits(&data,
405 &bit_pos,
406 &bit_store,
407 &written,
408 1, 0); /* vol_quarter_pixel = 0 */
409 putbits(&data,
410 &bit_pos,
411 &bit_store,
412 &written,
413 1, 1); /* complexity_estimation_disabled = 1 */
414 putbits(&data,
415 &bit_pos,
416 &bit_store,
417 &written,
418 1, 1); /* resync_marker_disabled = 1 */
419 putbits(&data,
420 &bit_pos,
421 &bit_store,
422 &written,
423 1, 0); /* data_partitioning_enabled = 0 */
424 putbits(&data,
425 &bit_pos,
426 &bit_store,
427 &written,
428 1, 0); /* scalability = 0 */
429
430 flushbits(&data,
431 &bit_pos,
432 &bit_store);
433
434
435
436 /*
437 * for(i = 0; i < data - data_start; i++)
438 * for(j = 0x80; j >= 1; j /= 2)
439 * printf("%d", (data_start[i] & j) ? 1 : 0);
440 * printf("\n");
441 */
442
443
444
445 return data - data_start;
446 }
447
448
449
450 // Create the header for the esds block which is used in mp4v.
451 // Taken from libavcodec
452 // Returns the size
453 static int write_mp4v_header(unsigned char *data,
454 int w,
455 int h,
456 double frame_rate)
457 {
458 unsigned char *start = data;
459 // Advanced simple level 1
460 int profile_level = 0xf3;
461 int vo_version_id = 5;
462
463
464
465
466
467 // VOS startcode
468 *data++ = 0x00;
469 *data++ = 0x00;
470 *data++ = 0x01;
471 *data++ = 0xb0;
472 *data++ = profile_level;
473
474 // Visual object startcode
475 *data++ = 0x00;
476 *data++ = 0x00;
477 *data++ = 0x01;
478 *data++ = 0xb5;
479 *data++ = (1 << 7) ||
480 (vo_version_id << 3) ||
481 // Priority
482 1;
483 // visual object type
484 *data++ = (1 << 4) ||
485 // Video signal type
486 0;
487 *data++ = 0x40;
488 *data++ = 0xc0;
489 *data++ = 0xcf;
490
491 // video object
492 int vol_size = quicktime_mpeg4_write_vol(data,
493 w,
494 h,
495 60000,
496 frame_rate);
497 data += vol_size;
498
499 return data - start;
500 }
501
502
503
504
505
506
507
508 // Mpeg-4 interface
509
510 static int reads_colormodel(quicktime_t *file,
511 int colormodel,
512 int track)
513 {
514 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
515 quicktime_codec_t *codec = (quicktime_codec_t*)vtrack->codec;
516 return (colormodel == BC_YUV420P &&
517 !quicktime_match_32(QUICKTIME_SVQ1, codec->fourcc));
518 }
519
520 static int writes_colormodel(quicktime_t *file,
521 int colormodel,
522 int track)
523 {
524 return (colormodel == BC_RGB888 ||
525 colormodel == BC_RGBA8888 ||
526 colormodel == BC_RGB161616 ||
527 colormodel == BC_RGBA16161616 ||
528 colormodel == BC_YUV888 ||
529 colormodel == BC_YUVA8888 ||
530 colormodel == BC_YUV161616 ||
531 colormodel == BC_YUVA16161616 ||
532 colormodel == BC_YUV420P ||
533 colormodel == BC_YUV422 ||
534 colormodel == BC_COMPRESSED);
535 }
536
537
538 static int delete_decoder(quicktime_mpeg4_codec_t *codec, int field)
539 {
540 if(codec->decode_initialized[field])
541 {
542 pthread_mutex_lock(&ffmpeg_lock);
543
544 avcodec_close(codec->decoder_context[field]);
545 free(codec->decoder_context[field]);
546
547 pthread_mutex_unlock(&ffmpeg_lock);
548 codec->decode_initialized[field] = 0;
549 }
550 }
551
552
553 static int init_decode(quicktime_mpeg4_codec_t *codec,
554 int current_field,
555 int width_i,
556 int height_i)
557 {
558
559 if(!ffmpeg_initialized)
560 {
561 ffmpeg_initialized = 1;
562 avcodec_init();
563 avcodec_register_all();
564 }
565
566
567 codec->decoder[current_field] = avcodec_find_decoder(codec->ffmpeg_id);
568 if(!codec->decoder[current_field])
569 {
570 printf("init_decode: avcodec_find_decoder returned NULL.\n");
571 return 1;
572 }
573
574 codec->decoder_context[current_field] = avcodec_alloc_context();
575 codec->decoder_context[current_field]->width = width_i;
576 codec->decoder_context[current_field]->height = height_i;
577 if(avcodec_open(codec->decoder_context[current_field],
578 codec->decoder[current_field]) < 0)
579 {
580 printf("init_decode: avcodec_open failed.\n");
581 }
582 return 0;
583 }
584
585
586 static int decode_wrapper(quicktime_t *file,
587 quicktime_video_map_t *vtrack,
588 quicktime_mpeg4_codec_t *codec,
589 int frame_number,
590 int current_field,
591 int track)
592 {
593
594 int got_picture = 0;
595 int result = 0;
596 int bytes = 0;
597 int header_bytes = 0;
598 char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
599 quicktime_trak_t *trak = vtrack->track;
600 quicktime_stsd_table_t *stsd_table = &trak->mdia.minf.stbl.stsd.table[0];
601 int width = trak->tkhd.track_width;
602 int height = trak->tkhd.track_height;
603 int width_i = (int)((float)width / 16 + 0.5) * 16;
604 int height_i = (int)((float)height / 16 + 0.5) * 16;
605
606 quicktime_set_video_position(file, frame_number, track);
607
608 bytes = quicktime_frame_size(file, frame_number, track);
609 if(frame_number == 0)
610 {
611 header_bytes = stsd_table->mpeg4_header_size;
612 }
613 //printf("decode_wrapper 1 %p %d %d %d\n", stsd_table, frame_number, bytes, header_bytes);
614
615 if(!codec->work_buffer || codec->buffer_size < bytes + header_bytes)
616 {
617 if(codec->work_buffer) free(codec->work_buffer);
618 codec->buffer_size = bytes + header_bytes;
619 codec->work_buffer = calloc(1, codec->buffer_size + 100);
620 }
621
622 if(header_bytes)
623 memcpy(codec->work_buffer, stsd_table->mpeg4_header, header_bytes);
624
625 //printf("decode_wrapper 1 %d %d\n", header_bytes, bytes);
626 if(!quicktime_read_data(file,
627 codec->work_buffer + header_bytes,
628 bytes))
629 result = -1;
630
631
632 if(!result)
633 {
634 /*
635 * if(!codec->got_key[current_field])
636 * {
637 * if(!quicktime_mpeg4_is_key(codec->work_buffer, bytes, compressor))
638 * return -1;
639 * else
640 * {
641 * codec->got_key[current_field] = 1;
642 * }
643 * }
644 */
645
646
647 // No way to determine if there was an error based on nonzero status.
648 // Need to test row pointers to determine if an error occurred.
649 result = avcodec_decode_video(codec->decoder_context[current_field],
650 &codec->picture[current_field],
651 &got_picture,
652 codec->work_buffer,
653 bytes + header_bytes);
654
655
656
657 if(codec->picture[current_field].data[0])
658 {
659 if(!codec->got_key[current_field])
660 {
661 codec->got_key[current_field] = 1;
662 }
663 result = 0;
664 }
665 else
666 {
667 // ffmpeg can't recover if the first frame errored out, like in a direct copy
668 // sequence.
669 /*
670 * delete_decoder(codec, current_field);
671 * init_decode(codec, current_field, width_i, height_i);
672 */
673 result = 1;
674 }
675
676 #ifdef ARCH_X86
677 asm("emms");
678 #endif
679 }
680
681 return result;
682 }
683
684 static int decode(quicktime_t *file, unsigned char **row_pointers, int track)
685 {
686 int i;
687 int result = 0;
688 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
689 quicktime_trak_t *trak = vtrack->track;
690 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
691 int width = trak->tkhd.track_width;
692 int height = trak->tkhd.track_height;
693 int width_i;
694 int height_i;
695 int use_temp = 0;
696 int input_cmodel;
697 int current_field = vtrack->current_position % codec->total_fields;
698 unsigned char **input_rows;
699 int seeking_done = 0;
700
701 if(codec->ffmpeg_id == CODEC_ID_SVQ1)
702 {
703 width_i = (int)((float)width / 16 + 0.5) * 32;
704 height_i = (int)((float)height / 16 + 0.5) * 32;
705 }
706 else
707 {
708 width_i = (int)((float)width / 16 + 0.5) * 16;
709 height_i = (int)((float)height / 16 + 0.5) * 16;
710 }
711
712 pthread_mutex_lock(&ffmpeg_lock);
713
714
715 if(!codec->decode_initialized[current_field])
716 {
717 int current_frame = vtrack->current_position;
718 init_decode(codec, current_field, width_i, height_i);
719 // Must decode frame with stream header first but only the first frame in the
720 // field sequence has a stream header.
721 result = decode_wrapper(file,
722 vtrack,
723 codec,
724 current_field,
725 current_field,
726 track);
727 // Reset position because decode wrapper set it
728 quicktime_set_video_position(file, current_frame, track);
729 codec->decode_initialized[current_field] = 1;
730 }
731
732 // Handle seeking
733 if(quicktime_has_keyframes(file, track) &&
734 vtrack->current_position != codec->last_frame[current_field] + codec->total_fields)
735 {
736 int frame1, frame2 = vtrack->current_position, current_frame = frame2;
737 int do_i_frame = 1;
738 //printf("decode 2\n");
739
740 // Get first keyframe of same field
741 do
742 {
743 frame1 = quicktime_get_keyframe_before(file,
744 current_frame--,
745 track);
746 }while(frame1 > 0 && (frame1 % codec->total_fields) != current_field);
747 //printf("decode 3\n");
748
749 // Keyframe is before last decoded frame and current frame is after last decoded
750 // frame, so instead of rerendering from the last keyframe we can rerender from
751 // the last decoded frame.
752 if(frame1 < codec->last_frame[current_field] &&
753 frame2 > codec->last_frame[current_field])
754 {
755 //printf("decode 1 %d %d\n", frame1, frame2);
756 frame1 = codec->last_frame[current_field] + codec->total_fields;
757 do_i_frame = 0;
758 }
759
760 while(frame1 <= frame2)
761 {
762 result = decode_wrapper(file,
763 vtrack,
764 codec,
765 frame1,
766 current_field,
767 track);
768
769
770 // May need to do the first I frame twice.
771 if(do_i_frame)
772 {
773 result = decode_wrapper(file,
774 vtrack,
775 codec,
776 frame1,
777 current_field,
778 track);
779 do_i_frame = 0;
780 }
781 frame1 += codec->total_fields;
782 }
783
784 vtrack->current_position = frame2;
785 seeking_done = 1;
786 }
787
788
789 if(!seeking_done)
790 {
791 result = decode_wrapper(file,
792 vtrack,
793 codec,
794 vtrack->current_position,
795 current_field,
796 track);
797 }
798 pthread_mutex_unlock(&ffmpeg_lock);
799
800
801
802 codec->last_frame[current_field] = vtrack->current_position;
803
804
805
806
807
808
809
810
811
812 // result = (result != 0);
813 switch(codec->decoder_context[current_field]->pix_fmt)
814 {
815 case PIX_FMT_YUV420P:
816 input_cmodel = BC_YUV420P;
817 break;
818 case PIX_FMT_YUV422:
819 input_cmodel = BC_YUV422;
820 break;
821 case PIX_FMT_YUV422P:
822 input_cmodel = BC_YUV422P;
823 break;
824 case PIX_FMT_YUV410P:
825 input_cmodel = BC_YUV9P;
826 break;
827 default:
828 fprintf(stderr,
829 "mpeg4 decode: unrecognized color model %d\n",
830 codec->decoder_context[current_field]->pix_fmt);
831 input_cmodel = BC_YUV420P;
832 break;
833 }
834
835
836
837
838
839 if(codec->picture[current_field].data[0])
840 {
841
842 input_rows =
843 malloc(sizeof(unsigned char*) *
844 codec->decoder_context[current_field]->height);
845
846
847 for(i = 0; i < codec->decoder_context[current_field]->height; i++)
848 input_rows[i] = codec->picture[current_field].data[0] +
849 i *
850 codec->decoder_context[current_field]->width *
851 cmodel_calculate_pixelsize(input_cmodel);
852
853
854 cmodel_transfer(row_pointers, /* Leave NULL if non existent */
855 input_rows,
856 row_pointers[0], /* Leave NULL if non existent */
857 row_pointers[1],
858 row_pointers[2],
859 codec->picture[current_field].data[0], /* Leave NULL if non existent */
860 codec->picture[current_field].data[1],
861 codec->picture[current_field].data[2],
862 file->in_x, /* Dimensions to capture from input frame */
863 file->in_y,
864 file->in_w,
865 file->in_h,
866 0, /* Dimensions to project on output frame */
867 0,
868 file->out_w,
869 file->out_h,
870 input_cmodel,
871 file->color_model,
872 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
873 codec->picture[current_field].linesize[0], /* For planar use the luma rowspan */
874 width);
875 free(input_rows);
876 }
877
878
879
880
881 return result;
882 }
883
884
885 static int encode(quicktime_t *file, unsigned char **row_pointers, int track)
886 {
887 int64_t offset = quicktime_position(file);
888 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
889 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
890 quicktime_trak_t *trak = vtrack->track;
891 int width = trak->tkhd.track_width;
892 int height = trak->tkhd.track_height;
893 int width_i = (int)((float)width / 16 + 0.5) * 16;
894 int height_i = (int)((float)height / 16 + 0.5) * 16;
895 int result = 0;
896 int i;
897 int bytes = 0;
898 int is_keyframe = 0;
899 int current_field = vtrack->current_position % codec->total_fields;
900 quicktime_atom_t chunk_atom;
901
902
903 //printf("encode 1\n");
904
905
906
907 pthread_mutex_lock(&ffmpeg_lock);
908
909
910
911 if(!codec->encode_initialized[current_field])
912 {
913 // Encore section
914 if(codec->ffmpeg_id == CODEC_ID_MPEG4)
915 {
916 codec->use_encore = 1;
917 codec->encode_initialized[current_field] = 1;
918 codec->encode_handle[current_field] = encode_handle++;
919 codec->enc_param[current_field].x_dim = width_i;
920 codec->enc_param[current_field].y_dim = height_i;
921 codec->enc_param[current_field].framerate =
922 quicktime_frame_rate(file, track) / codec->total_fields;
923 codec->enc_param[current_field].bitrate =
924 codec->bitrate / codec->total_fields;
925 codec->enc_param[current_field].rc_period = codec->rc_period;
926 codec->enc_param[current_field].rc_reaction_period = codec->rc_reaction_period;
927 codec->enc_param[current_field].rc_reaction_ratio = codec->rc_reaction_ratio;
928 codec->enc_param[current_field].max_quantizer = codec->max_quantizer;
929 codec->enc_param[current_field].min_quantizer = codec->min_quantizer;
930 codec->enc_param[current_field].max_key_interval = codec->max_key_interval;
931
932 codec->enc_param[current_field].search_range = codec->quality * 3;
933 if(codec->enc_param[current_field].search_range > 15)
934 codec->enc_param[current_field].search_range = 15;
935
936 encore(codec->encode_handle[current_field],
937 ENC_OPT_INIT,
938 &codec->enc_param[current_field], NULL);
939
940
941 // Create esds header
942 if(!strcmp(((quicktime_codec_t*)vtrack->codec)->fourcc, QUICKTIME_MP4V))
943 {
944 unsigned char temp[256];
945 int size = write_mp4v_header(temp,
946 width,
947 height,
948 quicktime_frame_rate(file, track));
949 quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0],
950 temp,
951 size);
952 }
953 }
954 else
955 // ffmpeg section
956 {
957 static char *video_rc_eq="tex^qComp";
958 codec->encode_initialized[current_field] = 1;
959 if(!ffmpeg_initialized)
960 {
961 ffmpeg_initialized = 1;
962 avcodec_init();
963 avcodec_register_all();
964 }
965
966 codec->encoder[current_field] = avcodec_find_encoder(codec->ffmpeg_id);
967 if(!codec->encoder[current_field])
968 {
969 printf("encode: avcodec_find_encoder returned NULL.\n");
970 pthread_mutex_unlock(&ffmpeg_lock);
971 return 1;
972 }
973
974 codec->encoder_context[current_field] = avcodec_alloc_context();
975 codec->encoder_context[current_field]->frame_rate = FRAME_RATE_BASE *
976 quicktime_frame_rate(file, track);
977 codec->encoder_context[current_field]->width = width_i;
978 codec->encoder_context[current_field]->height = height_i;
979 codec->encoder_context[current_field]->gop_size = codec->gop_size;
980 codec->encoder_context[current_field]->pix_fmt = PIX_FMT_YUV420P;
981 codec->encoder_context[current_field]->bit_rate = codec->bitrate;
982 codec->encoder_context[current_field]->bit_rate_tolerance = codec->bitrate_tolerance;
983 codec->encoder_context[current_field]->rc_eq = video_rc_eq;
984 codec->encoder_context[current_field]->qmin = 2;
985 codec->encoder_context[current_field]->qmax = 31;
986 codec->encoder_context[current_field]->max_qdiff = 3;
987 codec->encoder_context[current_field]->qblur = 0.5;
988 codec->encoder_context[current_field]->qcompress = 0.5;
989 codec->encoder_context[current_field]->me_method = ME_FULL;
990
991 printf("encode %d %d %d %d %d\n", codec->gop_size, codec->bitrate, codec->bitrate_tolerance, codec->fix_bitrate, codec->interlaced);
992
993
994 if(!codec->fix_bitrate)
995 {
996 codec->encoder_context[current_field]->flags |= CODEC_FLAG_QSCALE;
997 }
998
999 if(codec->interlaced)
1000 {
1001 codec->encoder_context[current_field]->flags |= CODEC_FLAG_INTERLACED_DCT;
1002 }
1003
1004 avcodec_open(codec->encoder_context[current_field], codec->encoder[current_field]);
1005
1006 }
1007 }
1008
1009
1010 if(!codec->work_buffer)
1011 {
1012 codec->buffer_size = width_i * height_i;
1013 codec->work_buffer = malloc(codec->buffer_size);
1014 }
1015
1016
1017
1018 // Encore section
1019 if(codec->use_encore)
1020 {
1021 // Encore section
1022 ENC_FRAME encore_input;
1023 ENC_RESULT encore_result;
1024
1025
1026 // Assume planes are contiguous.
1027 // Encode directly from function arguments
1028 if(file->color_model == BC_YUV420P &&
1029 width == width_i &&
1030 height == height_i)
1031 {
1032 encore_input.image = row_pointers[0];
1033 }
1034 // Convert to YUV420P
1035 // Encode from temporary.
1036 else
1037 {
1038 if(!codec->temp_frame)
1039 {
1040 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
1041 }
1042
1043 cmodel_transfer(0, /* Leave NULL if non existent */
1044 row_pointers,
1045 codec->temp_frame, /* Leave NULL if non existent */
1046 codec->temp_frame + width_i * height_i,
1047 codec->temp_frame + width_i * height_i + width_i * height_i / 4,
1048 row_pointers[0], /* Leave NULL if non existent */
1049 row_pointers[1],
1050 row_pointers[2],
1051 0, /* Dimensions to capture from input frame */
1052 0,
1053 width,
1054 height,
1055 0, /* Dimensions to project on output frame */
1056 0,
1057 width,
1058 height,
1059 file->color_model,
1060 BC_YUV420P,
1061 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
1062 width, /* For planar use the luma rowspan */
1063 width_i);
1064
1065
1066 encore_input.image = codec->temp_frame;
1067 }
1068
1069
1070
1071 bzero(codec->work_buffer, codec->buffer_size);
1072 encore_input.bitstream = codec->work_buffer;
1073 encore_input.length = 0;
1074 encore_input.quant = !codec->fix_bitrate ? codec->quantizer : 0;
1075
1076 if(codec->p_count == 0)
1077 {
1078 codec->p_count[current_field]++;
1079 }
1080 else
1081 {
1082 codec->p_count[current_field]++;
1083 if(codec->p_count[current_field] >= codec->max_key_interval)
1084 codec->p_count[current_field] = 0;
1085 }
1086
1087 encore(codec->encode_handle[current_field],
1088 0,
1089 &encore_input,
1090 &encore_result);
1091
1092 bytes = encore_input.length;
1093 is_keyframe = encore_result.isKeyFrame;
1094 }
1095 else
1096 // ffmpeg section
1097 {
1098 AVFrame pict_tmp;
1099
1100 if(width_i == width &&
1101 height_i == height &&
1102 file->color_model == BC_YUV420P)
1103 {
1104 pict_tmp.data[0] = row_pointers[0];
1105 pict_tmp.data[1] = row_pointers[1];
1106 pict_tmp.data[2] = row_pointers[2];
1107 pict_tmp.linesize[0] = width_i;
1108 pict_tmp.linesize[1] = width_i / 2;
1109 pict_tmp.linesize[2] = width_i / 2;
1110 }
1111 else
1112 {
1113 if(!codec->temp_frame)
1114 {
1115 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
1116 }
1117
1118 cmodel_transfer(0, /* Leave NULL if non existent */
1119 row_pointers,
1120 codec->temp_frame, /* Leave NULL if non existent */
1121 codec->temp_frame + width_i * height_i,
1122 codec->temp_frame + width_i * height_i + width_i * height_i / 4,
1123 row_pointers[0], /* Leave NULL if non existent */
1124 row_pointers[1],
1125 row_pointers[2],
1126 0, /* Dimensions to capture from input frame */
1127 0,
1128 width,
1129 height,
1130 0, /* Dimensions to project on output frame */
1131 0,
1132 width,
1133 height,
1134 file->color_model,
1135 BC_YUV420P,
1136 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
1137 width, /* For planar use the luma rowspan */
1138 width_i);
1139
1140 pict_tmp.data[0] = codec->temp_frame;
1141 pict_tmp.data[1] = codec->temp_frame + width_i * height_i;
1142 pict_tmp.data[2] = codec->temp_frame + width_i * height_i + width_i * height_i / 4;
1143 pict_tmp.linesize[0] = width_i;
1144 pict_tmp.linesize[1] = width_i / 2;
1145 pict_tmp.linesize[2] = width_i / 2;
1146 }
1147
1148
1149 if(codec->quantizer >= 0)
1150 pict_tmp.quality = codec->quantizer;
1151 bytes = avcodec_encode_video(codec->encoder_context[current_field],
1152 codec->work_buffer,
1153 codec->buffer_size,
1154 &pict_tmp);
1155 is_keyframe = pict_tmp.key_frame;
1156 }
1157
1158
1159
1160
1161
1162
1163 pthread_mutex_unlock(&ffmpeg_lock);
1164 quicktime_write_chunk_header(file, trak, &chunk_atom);
1165 result = !quicktime_write_data(file,
1166 codec->work_buffer,
1167 bytes);
1168 quicktime_write_chunk_footer(file,
1169 trak,
1170 vtrack->current_chunk,
1171 &chunk_atom,
1172 1);
1173 if(is_keyframe)
1174 quicktime_insert_keyframe(file,
1175 vtrack->current_position,
1176 track);
1177 //printf("encode 10\n");
1178
1179 vtrack->current_chunk++;
1180 return result;
1181 }
1182
1183
1184
1185
1186
1187
1188
1189 static int set_parameter(quicktime_t *file,
1190 int track,
1191 char *key,
1192 void *value)
1193 {
1194 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
1195 char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
1196
1197 if(quicktime_match_32(compressor, QUICKTIME_DIVX) ||
1198 quicktime_match_32(compressor, QUICKTIME_HV60))
1199 {
1200 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1201
1202 if(!strcasecmp(key, "divx_bitrate"))
1203 codec->bitrate = *(int*)value;
1204 else
1205 if(!strcasecmp(key, "divx_rc_period"))
1206 codec->rc_period = *(int*)value;
1207 else
1208 if(!strcasecmp(key, "divx_rc_reaction_ratio"))
1209 codec->rc_reaction_ratio = *(int*)value;
1210 else
1211 if(!strcasecmp(key, "divx_rc_reaction_period"))
1212 codec->rc_reaction_period = *(int*)value;
1213 else
1214 if(!strcasecmp(key, "divx_max_key_interval"))
1215 codec->max_key_interval = *(int*)value;
1216 else
1217 if(!strcasecmp(key, "divx_max_quantizer"))
1218 codec->max_quantizer = *(int*)value;
1219 else
1220 if(!strcasecmp(key, "divx_min_quantizer"))
1221 codec->min_quantizer = *(int*)value;
1222 else
1223 if(!strcasecmp(key, "divx_quantizer"))
1224 codec->quantizer = *(int*)value;
1225 else
1226 if(!strcasecmp(key, "divx_quality"))
1227 codec->quality = *(int*)value;
1228 else
1229 if(!strcasecmp(key, "divx_fix_bitrate"))
1230 codec->fix_bitrate = *(int*)value;
1231 else
1232 if(!strcasecmp(key, "divx_use_deblocking"))
1233 codec->use_deblocking = *(int*)value;
1234 }
1235 else
1236 if(quicktime_match_32(compressor, QUICKTIME_DIV3))
1237 {
1238 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1239 if(!strcasecmp(key, "div3_bitrate"))
1240 codec->bitrate = *(int*)value;
1241 else
1242 if(!strcasecmp(key, "div3_bitrate_tolerance"))
1243 codec->bitrate_tolerance = *(int*)value;
1244 else
1245 if(!strcasecmp(key, "div3_interlaced"))
1246 codec->interlaced = *(int*)value;
1247 else
1248 if(!strcasecmp(key, "div3_gop_size"))
1249 codec->gop_size = *(int*)value;
1250 else
1251 if(!strcasecmp(key, "div3_quantizer"))
1252 codec->quantizer = *(int*)value;
1253 else
1254 if(!strcasecmp(key, "div3_fix_bitrate"))
1255 codec->fix_bitrate = *(int*)value;
1256 }
1257 return 0;
1258 }
1259
1260
1261
1262 static int delete_codec(quicktime_video_map_t *vtrack)
1263 {
1264 quicktime_mpeg4_codec_t *codec;
1265 int i;
1266
1267
1268 codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1269 for(i = 0; i < codec->total_fields; i++)
1270 {
1271 if(codec->encode_initialized[i])
1272 {
1273 pthread_mutex_lock(&ffmpeg_lock);
1274 if(codec->use_encore)
1275 {
1276 encore(codec->encode_handle[i],
1277 ENC_OPT_RELEASE,
1278 0,
1279 0);
1280 }
1281 else
1282 {
1283 avcodec_close(codec->encoder_context[i]);
1284 free(codec->encoder_context[i]);
1285 }
1286 pthread_mutex_unlock(&ffmpeg_lock);
1287 }
1288 delete_decoder(codec, i);
1289 }
1290
1291
1292 if(codec->temp_frame) free(codec->temp_frame);
1293 if(codec->work_buffer) free(codec->work_buffer);
1294
1295
1296 free(codec);
1297 return 0;
1298 }
1299
1300
1301
1302
1303 static quicktime_mpeg4_codec_t* init_common(quicktime_video_map_t *vtrack,
1304 char *compressor,
1305 char *title,
1306 char *description)
1307 {
1308 quicktime_codec_t *codec_base = (quicktime_codec_t*)vtrack->codec;
1309 quicktime_mpeg4_codec_t *codec;
1310
1311 codec_base->priv = calloc(1, sizeof(quicktime_mpeg4_codec_t));
1312 codec_base->delete_vcodec = delete_codec;
1313 codec_base->decode_video = decode;
1314 codec_base->encode_video = encode;
1315 codec_base->reads_colormodel = reads_colormodel;
1316 codec_base->writes_colormodel = writes_colormodel;
1317 codec_base->set_parameter = set_parameter;
1318 codec_base->fourcc = compressor;
1319 codec_base->title = title;
1320 codec_base->desc = description;
1321
1322 codec = (quicktime_mpeg4_codec_t*)codec_base->priv;
1323
1324
1325
1326 // Set defaults
1327 codec->bitrate = 1000000;
1328 codec->rc_period = 50;
1329 codec->rc_reaction_ratio = 45;
1330 codec->rc_reaction_period = 10;
1331 codec->max_key_interval = 45;
1332 codec->max_quantizer = 31;
1333 codec->min_quantizer = 1;
1334 codec->quantizer = 10;
1335 codec->quality = 5;
1336 codec->fix_bitrate = 1;
1337 codec->total_fields = 1;
1338
1339
1340
1341 return codec;
1342 }
1343
1344
1345
1346
1347 // Mike Rowe Soft MPEG-4
1348 void quicktime_init_codec_div3(quicktime_video_map_t *vtrack)
1349 {
1350 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1351 QUICKTIME_DIV3,
1352 "DIVX",
1353 "Mike Row Soft MPEG4 Version 3");
1354 result->ffmpeg_id = CODEC_ID_MSMPEG4V3;
1355 }
1356
1357 // Mike Rowe Soft MPEG-4
1358 void quicktime_init_codec_div3lower(quicktime_video_map_t *vtrack)
1359 {
1360 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1361 QUICKTIME_DIV3_LOWER,
1362 "DIVX",
1363 "Mike Row Soft MPEG4 Version 3");
1364 result->ffmpeg_id = CODEC_ID_MSMPEG4V3;
1365 }
1366
1367
1368 // Generic MPEG-4
1369 void quicktime_init_codec_divx(quicktime_video_map_t *vtrack)
1370 {
1371 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1372 QUICKTIME_DIVX,
1373 "MPEG4",
1374 "Generic MPEG Four");
1375 result->ffmpeg_id = CODEC_ID_MPEG4;
1376 }
1377
1378 // Generic MPEG-4
1379 void quicktime_init_codec_mp4v(quicktime_video_map_t *vtrack)
1380 {
1381 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1382 QUICKTIME_MP4V,
1383 "MPEG4",
1384 "Generic MPEG Four");
1385 result->ffmpeg_id = CODEC_ID_MPEG4;
1386 }
1387
1388
1389 // Mormon MPEG-4
1390 void quicktime_init_codec_svq1(quicktime_video_map_t *vtrack)
1391 {
1392 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1393 QUICKTIME_SVQ1,
1394 "Sorenson Version 1",
1395 "From the chearch of codecs of yesterday's sights");
1396 result->ffmpeg_id = CODEC_ID_SVQ1;
1397 }
1398
1399 void quicktime_init_codec_svq3(quicktime_video_map_t *vtrack)
1400 {
1401 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1402 QUICKTIME_SVQ3,
1403 "Sorenson Version 3",
1404 "From the chearch of codecs of yesterday's sights");
1405 result->ffmpeg_id = CODEC_ID_SVQ3;
1406 }
1407
1408 void quicktime_init_codec_h263(quicktime_video_map_t *vtrack)
1409 {
1410 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1411 QUICKTIME_H263,
1412 "h263",
1413 "H.263");
1414 result->ffmpeg_id = CODEC_ID_H263;
1415 }
1416
1417 // field based MPEG-4
1418 void quicktime_init_codec_hv60(quicktime_video_map_t *vtrack)
1419 {
1420 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1421 QUICKTIME_HV60,
1422 "Heroine 60",
1423 "MPEG 4 with alternating streams every other frame. (Not standardized)");
1424 result->total_fields = 2;
1425 result->ffmpeg_id = CODEC_ID_MPEG4;
1426 }
1427
1428
1429
1430
1431
1432
mob repository