?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r793: Small API addon, so plugins can 'see' camera and projector automation
[cinelerra_cv/mob.git] / quicktime / mpeg4.c
blob3065d3875ba23bbf6266ab99396bfb5c22559eae
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 "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 #include <string.h>
24
25 #define FRAME_RATE_BASE 10000
26
27
28 typedef struct
29 {
30 #define FIELDS 2
31 int decode_initialized[FIELDS];
32
33
34 // FFMpeg internals
35 AVCodec *decoder[FIELDS];
36 AVCodecContext *decoder_context[FIELDS];
37 AVFrame picture[FIELDS];
38
39
40 // Decore internals
41 // DEC_PARAM dec_param[FIELDS];
42 // int decode_handle[FIELDS];
43
44 // Last frame decoded
45 long last_frame[FIELDS];
46
47 int got_key[FIELDS];
48
49
50
51
52
53
54
55
56
57
58 int encode_initialized[FIELDS];
59 // Information for picking the right library routines.
60 // ID out of avcodec.h for the codec used.
61 // Invalid if encore50 is used.
62 int ffmpeg_id;
63 // True if encore50 is being used.
64 int use_encore;
65
66 // FFMpeg internals
67 AVCodec *encoder[FIELDS];
68 AVCodecContext *encoder_context[FIELDS];
69
70
71 // Encore internals
72 int encode_handle[FIELDS];
73 ENC_PARAM enc_param[FIELDS];
74 // Must count pframes in VBR
75 int p_count[FIELDS];
76
77
78 // Encoding parameters
79 int bitrate;
80 // For heroine 60 encoding, we want different streams for each field.
81 int total_fields;
82 long rc_period; // the intended rate control averaging period
83 long rc_reaction_period; // the reation period for rate control
84 long rc_reaction_ratio; // the ratio for down/up rate control
85 long max_key_interval; // the maximum interval between key frames
86 int bitrate_tolerance;
87 int interlaced;
88 int gop_size;
89 int max_quantizer; // the upper limit of the quantizer
90 int min_quantizer; // the lower limit of the quantizer
91 int quantizer; // For vbr
92 int quality; // the forward search range for motion estimation
93 int fix_bitrate;
94 int use_deblocking;
95
96
97 // Temporary storage for color conversions
98 char *temp_frame;
99 // Storage of compressed data
100 unsigned char *work_buffer;
101 // Allocation of work_buffer
102 int buffer_size;
103 } quicktime_mpeg4_codec_t;
104
105
106
107 // Decore needs the user to specify handles
108 static int decode_handle = 1;
109 static int encode_handle = 0;
110
111
112
113
114
115
116
117
118
119 // Direct copy routines
120
121
122 // Determine of the compressed frame is a keyframe for direct copy
123 int quicktime_mpeg4_is_key(unsigned char *data, long size, char *codec_id)
124 {
125 int result = 0;
126 int i;
127
128 if(quicktime_match_32(codec_id, QUICKTIME_DIVX) ||
129 quicktime_match_32(codec_id, QUICKTIME_MP4V) ||
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 = quicktime_quantize16(vol_width);
230 vol_height = quicktime_quantize16(vol_height);
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 putbits(&data,
253 &bit_pos,
254 &bit_store,
255 &written,
256 4, 0); /* vol_id = 0 */
257
258 putbits(&data,
259 &bit_pos,
260 &bit_store,
261 &written,
262 1, 0); /* random_accessible_vol = 0 */
263 putbits(&data,
264 &bit_pos,
265 &bit_store,
266 &written,
267 8, 1); /* video_object_type_indication = 1 video */
268 putbits(&data,
269 &bit_pos,
270 &bit_store,
271 &written,
272 1, 1); /* is_object_layer_identifier = 1 */
273 putbits(&data,
274 &bit_pos,
275 &bit_store,
276 &written,
277 4, 2); /* visual_object_layer_ver_id = 2 */
278 putbits(&data,
279 &bit_pos,
280 &bit_store,
281 &written,
282 3, 1); /* visual_object_layer_priority = 1 */
283 putbits(&data,
284 &bit_pos,
285 &bit_store,
286 &written,
287 4, 1); /* aspect_ratio_info = 1 */
288
289
290
291
292
293
294
295 putbits(&data,
296 &bit_pos,
297 &bit_store,
298 &written,
299 1, 0); /* vol_control_parameter = 0 */
300 putbits(&data,
301 &bit_pos,
302 &bit_store,
303 &written,
304 2, 0); /* vol_shape = 0 rectangular */
305 putbits(&data,
306 &bit_pos,
307 &bit_store,
308 &written,
309 1, 1); /* marker */
310
311
312
313
314
315
316
317 putbits(&data,
318 &bit_pos,
319 &bit_store,
320 &written,
321 16, time_increment_resolution);
322 putbits(&data,
323 &bit_pos,
324 &bit_store,
325 &written,
326 1, 1); /* marker */
327 putbits(&data,
328 &bit_pos,
329 &bit_store,
330 &written,
331 1, 1); /* fixed_vop_rate = 1 */
332
333
334 bits = 1;
335 while((1 << bits) < time_increment_resolution) bits++;
336
337 // Log calculation fails for some reason
338 // bits = (int)ceil(log((double)time_increment_resolution) / log(2.0));
339 // if (bits < 1) bits=1;
340
341 fixed_vop_time_increment =
342 (int)(time_increment_resolution / frame_rate + 0.1);
343
344 putbits(&data,
345 &bit_pos,
346 &bit_store,
347 &written,
348 bits, fixed_vop_time_increment);
349
350 putbits(&data,
351 &bit_pos,
352 &bit_store,
353 &written,
354 1, 1); /* marker */
355
356 putbits(&data,
357 &bit_pos,
358 &bit_store,
359 &written,
360 13, vol_width);
361 putbits(&data,
362 &bit_pos,
363 &bit_store,
364 &written,
365 1, 1); /* marker */
366 putbits(&data,
367 &bit_pos,
368 &bit_store,
369 &written,
370 13, vol_height);
371 putbits(&data,
372 &bit_pos,
373 &bit_store,
374 &written,
375 1, 1); /* marker */
376
377 putbits(&data,
378 &bit_pos,
379 &bit_store,
380 &written,
381 1, 0); /* interlaced = 0 */
382 putbits(&data,
383 &bit_pos,
384 &bit_store,
385 &written,
386 1, 1); /* OBMC_disabled = 1 */
387 putbits(&data,
388 &bit_pos,
389 &bit_store,
390 &written,
391 2, 0); /* vol_sprite_usage = 0 */
392 putbits(&data,
393 &bit_pos,
394 &bit_store,
395 &written,
396 1, 0); /* not_8_bit = 0 */
397
398 putbits(&data,
399 &bit_pos,
400 &bit_store,
401 &written,
402 1, 0); /* vol_quant_type = 0 */
403 putbits(&data,
404 &bit_pos,
405 &bit_store,
406 &written,
407 1, 0); /* vol_quarter_pixel = 0 */
408 putbits(&data,
409 &bit_pos,
410 &bit_store,
411 &written,
412 1, 1); /* complexity_estimation_disabled = 1 */
413 putbits(&data,
414 &bit_pos,
415 &bit_store,
416 &written,
417 1, 1); /* resync_marker_disabled = 1 */
418 putbits(&data,
419 &bit_pos,
420 &bit_store,
421 &written,
422 1, 0); /* data_partitioning_enabled = 0 */
423 putbits(&data,
424 &bit_pos,
425 &bit_store,
426 &written,
427 1, 0); /* scalability = 0 */
428
429 flushbits(&data,
430 &bit_pos,
431 &bit_store);
432
433
434 /*
435 * for(i = 0; i < data - data_start; i++)
436 * for(j = 0x80; j >= 1; j /= 2)
437 * printf("%d", (data_start[i] & j) ? 1 : 0);
438 * printf("\n");
439 */
440
441
442
443 return data - data_start;
444 }
445
446
447
448 // Create the header for the esds block which is used in mp4v.
449 // Taken from libavcodec
450 // Returns the size
451 static int write_mp4v_header(unsigned char *data,
452 int w,
453 int h,
454 double frame_rate)
455 {
456 unsigned char *start = data;
457
458
459 /*
460 * static unsigned char test[] =
461 * {
462 *
463 * 0x00, 0x00, 0x01, 0xb0, 0x01, 0x00, 0x00, 0x01, 0xb5, 0x89, 0x13,
464 * 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0xc4, 0x8d,
465 * 0x8a, 0xee, 0x05, 0x28, 0x04, 0x5a, 0x14, 0x63, 0x00, 0x00, 0x01, 0xb2,
466 * 0x46, 0x46, 0x6d, 0x70, 0x65, 0x67, 0x43, 0x56, 0x53, 0x62, 0x34, 0x37,
467 * 0x35, 0x38
468 *
469 * };
470 * memcpy(data, test, sizeof(test));
471 *
472 * return sizeof(test);
473 */
474
475 // From ffmpeg
476 // Advanced simple level 1
477 // int profile_level = 0xf3;
478
479 int profile_level = 0x1;
480 // int vo_version_id = 5;
481 int vo_version_id = 1;
482
483
484
485
486
487 // VOS startcode
488 *data++ = 0x00;
489 *data++ = 0x00;
490 *data++ = 0x01;
491 *data++ = 0xb0;
492 *data++ = profile_level;
493
494 // Visual object startcode
495 *data++ = 0x00;
496 *data++ = 0x00;
497 *data++ = 0x01;
498 *data++ = 0xb5;
499 *data++ = ((unsigned char)0x1 << 7) |
500 ((unsigned char)vo_version_id << 3) |
501 // Priority
502 (unsigned char)1;
503 // visual object type video
504 *data++ = (0x1 << 4) |
505 // Video signal type
506 (0 << 3) |
507 // Stuffing
508 0x3;
509
510 // *data++ = 0x40;
511 // *data++ = 0xc0;
512 // *data++ = 0xcf;
513
514 // video object
515 int vol_size = quicktime_mpeg4_write_vol(data,
516 w,
517 h,
518 60000,
519 frame_rate);
520 data += vol_size;
521
522 return data - start;
523 }
524
525
526
527
528
529
530
531 // Mpeg-4 interface
532
533 static int reads_colormodel(quicktime_t *file,
534 int colormodel,
535 int track)
536 {
537 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
538 quicktime_codec_t *codec = (quicktime_codec_t*)vtrack->codec;
539 return (colormodel == BC_YUV420P &&
540 !quicktime_match_32(QUICKTIME_SVQ1, codec->fourcc));
541 }
542
543 static int writes_colormodel(quicktime_t *file,
544 int colormodel,
545 int track)
546 {
547 return colormodel == BC_YUV420P;
548 }
549
550
551 static int delete_decoder(quicktime_mpeg4_codec_t *codec, int field)
552 {
553 if(codec->decode_initialized[field])
554 {
555 pthread_mutex_lock(&ffmpeg_lock);
556
557 avcodec_close(codec->decoder_context[field]);
558 free(codec->decoder_context[field]);
559
560 pthread_mutex_unlock(&ffmpeg_lock);
561 codec->decode_initialized[field] = 0;
562 }
563 }
564
565
566 static int init_decode(quicktime_t *file,
567 quicktime_mpeg4_codec_t *codec,
568 quicktime_trak_t *trak,
569 int current_field,
570 int width_i,
571 int height_i)
572 {
573 quicktime_stsd_table_t *stsd_table = &trak->mdia.minf.stbl.stsd.table[0];
574 quicktime_esds_t *esds = &stsd_table->esds;
575
576 if(!ffmpeg_initialized)
577 {
578 ffmpeg_initialized = 1;
579 avcodec_init();
580 avcodec_register_all();
581 }
582
583
584 codec->decoder[current_field] = avcodec_find_decoder(codec->ffmpeg_id);
585 if(!codec->decoder[current_field])
586 {
587 printf("init_decode: avcodec_find_decoder returned NULL.\n");
588 return 1;
589 }
590
591 AVCodecContext *context =
592 codec->decoder_context[current_field] =
593 avcodec_alloc_context();
594 context->width = width_i;
595 context->height = height_i;
596
597
598 if(esds->mpeg4_header && esds->mpeg4_header_size)
599 {
600 context->extradata = esds->mpeg4_header;
601 context->extradata_size = esds->mpeg4_header_size;
602 }
603
604 if(file->cpus > 1)
605 {
606 avcodec_thread_init(context, file->cpus);
607 context->thread_count = file->cpus;
608 }
609
610 if(avcodec_open(context,
611 codec->decoder[current_field]) < 0)
612 {
613 printf("init_decode: avcodec_open failed.\n");
614 }
615 return 0;
616 }
617
618
619 static int decode_wrapper(quicktime_t *file,
620 quicktime_video_map_t *vtrack,
621 quicktime_mpeg4_codec_t *codec,
622 int frame_number,
623 int current_field,
624 int track,
625 int drop_it)
626 {
627
628 int got_picture = 0;
629 int result = 0;
630 int bytes = 0;
631 int header_bytes = 0;
632 char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
633 quicktime_trak_t *trak = vtrack->track;
634 quicktime_stsd_table_t *stsd_table = &trak->mdia.minf.stbl.stsd.table[0];
635 int width = trak->tkhd.track_width;
636 int height = trak->tkhd.track_height;
637 int width_i;
638 int height_i;
639
640 if(codec->ffmpeg_id == CODEC_ID_SVQ1)
641 {
642 width_i = quicktime_quantize32(width);
643 height_i = quicktime_quantize32(height);
644 }
645 else
646 {
647 width_i = quicktime_quantize16(width);
648 height_i = quicktime_quantize16(height);
649 }
650
651
652 quicktime_set_video_position(file, frame_number, track);
653
654 bytes = quicktime_frame_size(file, frame_number, track);
655 if(frame_number == 0 && codec->ffmpeg_id == CODEC_ID_SVQ3 && stsd_table->extradata)
656 {
657 codec->decoder_context[current_field]->extradata_size = stsd_table->extradata_size;
658 codec->decoder_context[current_field]->extradata = stsd_table->extradata;
659 } else
660 if(frame_number == 0)
661 {
662 header_bytes = stsd_table->esds.mpeg4_header_size;
663 }
664
665 if(!codec->work_buffer || codec->buffer_size < bytes + header_bytes)
666 {
667 if(codec->work_buffer) free(codec->work_buffer);
668 codec->buffer_size = bytes + header_bytes;
669 codec->work_buffer = calloc(1, codec->buffer_size + 100);
670 }
671
672 // Special handling of SVQ3 codec (some others might be alike)
673
674 if(header_bytes)
675 memcpy(codec->work_buffer, stsd_table->esds.mpeg4_header, header_bytes);
676
677 if(!quicktime_read_data(file,
678 codec->work_buffer + header_bytes,
679 bytes))
680 result = -1;
681
682
683 if(!result)
684 {
685 /*
686 * if(!codec->got_key[current_field])
687 * {
688 * if(!quicktime_mpeg4_is_key(codec->work_buffer, bytes, compressor))
689 * return -1;
690 * else
691 * {
692 * codec->got_key[current_field] = 1;
693 * }
694 * }
695 */
696
697
698 // No way to determine if there was an error based on nonzero status.
699 // Need to test row pointers to determine if an error occurred.
700 if(drop_it)
701 codec->decoder_context[current_field]->skip_frame = AVDISCARD_NONREF;
702 else
703 codec->decoder_context[current_field]->skip_frame = AVDISCARD_DEFAULT;
704 result = avcodec_decode_video(codec->decoder_context[current_field],
705 &codec->picture[current_field],
706 &got_picture,
707 codec->work_buffer,
708 bytes + header_bytes);
709
710
711
712 if(codec->picture[current_field].data[0])
713 {
714 if(!codec->got_key[current_field])
715 {
716 codec->got_key[current_field] = 1;
717 }
718 result = 0;
719 }
720 else
721 {
722 // ffmpeg can't recover if the first frame errored out, like in a direct copy
723 // sequence.
724 /*
725 * delete_decoder(codec, current_field);
726 * init_decode(codec, current_field, width_i, height_i);
727 */
728 result = 1;
729 }
730
731 #ifdef ARCH_X86
732 asm("emms");
733 #endif
734 }
735
736 return result;
737 }
738
739 static int decode(quicktime_t *file, unsigned char **row_pointers, int track)
740 {
741 int i;
742 int result = 0;
743 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
744 quicktime_trak_t *trak = vtrack->track;
745 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
746 int width = trak->tkhd.track_width;
747 int height = trak->tkhd.track_height;
748 int width_i;
749 int height_i;
750 int use_temp = 0;
751 int input_cmodel;
752 int current_field = vtrack->current_position % codec->total_fields;
753 unsigned char **input_rows;
754 int seeking_done = 0;
755
756 if(codec->ffmpeg_id == CODEC_ID_SVQ1)
757 {
758 width_i = quicktime_quantize32(width);
759 height_i = quicktime_quantize32(height);
760 }
761 else
762 {
763 width_i = quicktime_quantize16(width);
764 height_i = quicktime_quantize16(height);
765 }
766
767 pthread_mutex_lock(&ffmpeg_lock);
768
769
770 if(!codec->decode_initialized[current_field])
771 {
772 int current_frame = vtrack->current_position;
773 init_decode(file, codec, trak, current_field, width_i, height_i);
774 // Must decode frame with stream header first but only the first frame in the
775 // field sequence has a stream header.
776 result = decode_wrapper(file,
777 vtrack,
778 codec,
779 current_field,
780 current_field,
781 track,
782 0);
783 // Reset position because decode wrapper set it
784 quicktime_set_video_position(file, current_frame, track);
785 codec->decode_initialized[current_field] = 1;
786 }
787
788 // Handle seeking
789 if(quicktime_has_keyframes(file, track) &&
790 vtrack->current_position != codec->last_frame[current_field] + codec->total_fields)
791 {
792 int frame1, frame2 = vtrack->current_position, current_frame = frame2;
793 int do_i_frame = 1;
794
795 // Get first keyframe of same field
796 do
797 {
798 frame1 = quicktime_get_keyframe_before(file,
799 current_frame--,
800 track);
801 }while(frame1 > 0 && (frame1 % codec->total_fields) != current_field);
802
803 // Keyframe is before last decoded frame and current frame is after last decoded
804 // frame, so instead of rerendering from the last keyframe we can rerender from
805 // the last decoded frame.
806 if(frame1 < codec->last_frame[current_field] &&
807 frame2 > codec->last_frame[current_field])
808 {
809 frame1 = codec->last_frame[current_field] + codec->total_fields;
810 do_i_frame = 0;
811 }
812
813 while(frame1 <= frame2)
814 {
815 result = decode_wrapper(file,
816 vtrack,
817 codec,
818 frame1,
819 current_field,
820 track,
821 (frame1 < frame2));
822
823
824 // May need to do the first I frame twice.
825 if(do_i_frame)
826 {
827 result = decode_wrapper(file,
828 vtrack,
829 codec,
830 frame1,
831 current_field,
832 track,
833 0);
834 do_i_frame = 0;
835 }
836 frame1 += codec->total_fields;
837 }
838
839 vtrack->current_position = frame2;
840 seeking_done = 1;
841 }
842
843
844 if(!seeking_done)
845 {
846 result = decode_wrapper(file,
847 vtrack,
848 codec,
849 vtrack->current_position,
850 current_field,
851 track,
852 0);
853 }
854 pthread_mutex_unlock(&ffmpeg_lock);
855
856
857
858 codec->last_frame[current_field] = vtrack->current_position;
859
860
861
862
863
864
865
866
867
868 // result = (result != 0);
869 switch(codec->decoder_context[current_field]->pix_fmt)
870 {
871 case PIX_FMT_YUV420P:
872 input_cmodel = BC_YUV420P;
873 break;
874 case PIX_FMT_YUV422:
875 input_cmodel = BC_YUV422;
876 break;
877 case PIX_FMT_YUV422P:
878 input_cmodel = BC_YUV422P;
879 break;
880 case PIX_FMT_YUV410P:
881 input_cmodel = BC_YUV9P;
882 break;
883 default:
884 fprintf(stderr,
885 "mpeg4 decode: unrecognized color model %d\n",
886 codec->decoder_context[current_field]->pix_fmt);
887 input_cmodel = BC_YUV420P;
888 break;
889 }
890
891
892
893
894
895 if(codec->picture[current_field].data[0])
896 {
897
898 input_rows =
899 malloc(sizeof(unsigned char*) *
900 codec->decoder_context[current_field]->height);
901
902
903 for(i = 0; i < codec->decoder_context[current_field]->height; i++)
904 input_rows[i] = codec->picture[current_field].data[0] +
905 i *
906 codec->decoder_context[current_field]->width *
907 cmodel_calculate_pixelsize(input_cmodel);
908
909
910 cmodel_transfer(row_pointers, /* Leave NULL if non existent */
911 input_rows,
912 row_pointers[0], /* Leave NULL if non existent */
913 row_pointers[1],
914 row_pointers[2],
915 codec->picture[current_field].data[0], /* Leave NULL if non existent */
916 codec->picture[current_field].data[1],
917 codec->picture[current_field].data[2],
918 file->in_x, /* Dimensions to capture from input frame */
919 file->in_y,
920 file->in_w,
921 file->in_h,
922 0, /* Dimensions to project on output frame */
923 0,
924 file->out_w,
925 file->out_h,
926 input_cmodel,
927 file->color_model,
928 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
929 codec->picture[current_field].linesize[0], /* For planar use the luma rowspan */
930 width);
931 free(input_rows);
932 }
933
934
935
936
937 return result;
938 }
939
940
941 static int encode(quicktime_t *file, unsigned char **row_pointers, int track)
942 {
943 int64_t offset = quicktime_position(file);
944 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
945 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
946 quicktime_trak_t *trak = vtrack->track;
947 int width = trak->tkhd.track_width;
948 int height = trak->tkhd.track_height;
949 int width_i = quicktime_quantize16(width);
950 int height_i = quicktime_quantize16(height);
951 int result = 0;
952 int i;
953 int bytes = 0;
954 int is_keyframe = 0;
955 int current_field = vtrack->current_position % codec->total_fields;
956 quicktime_atom_t chunk_atom;
957
958
959
960
961
962 pthread_mutex_lock(&ffmpeg_lock);
963
964
965
966 if(!codec->encode_initialized[current_field])
967 {
968 // Encore section
969 if(codec->ffmpeg_id == CODEC_ID_MPEG4 && codec->use_encore)
970 {
971 codec->encode_initialized[current_field] = 1;
972 codec->encode_handle[current_field] = encode_handle++;
973 codec->enc_param[current_field].x_dim = width_i;
974 codec->enc_param[current_field].y_dim = height_i;
975 codec->enc_param[current_field].framerate =
976 quicktime_frame_rate(file, track) / codec->total_fields;
977 codec->enc_param[current_field].bitrate =
978 codec->bitrate / codec->total_fields;
979 codec->enc_param[current_field].rc_period = codec->rc_period;
980 codec->enc_param[current_field].rc_reaction_period = codec->rc_reaction_period;
981 codec->enc_param[current_field].rc_reaction_ratio = codec->rc_reaction_ratio;
982 codec->enc_param[current_field].max_quantizer = codec->max_quantizer;
983 codec->enc_param[current_field].min_quantizer = codec->min_quantizer;
984 codec->enc_param[current_field].max_key_interval = codec->max_key_interval;
985
986 codec->enc_param[current_field].search_range = codec->quality * 3;
987 if(codec->enc_param[current_field].search_range > 15)
988 codec->enc_param[current_field].search_range = 15;
989
990 encore(codec->encode_handle[current_field],
991 ENC_OPT_INIT,
992 &codec->enc_param[current_field], NULL);
993
994 }
995 else
996 // ffmpeg section
997 {
998 static char *video_rc_eq="tex^qComp";
999 codec->encode_initialized[current_field] = 1;
1000 if(!ffmpeg_initialized)
1001 {
1002 ffmpeg_initialized = 1;
1003 avcodec_init();
1004 avcodec_register_all();
1005 }
1006
1007 codec->encoder[current_field] = avcodec_find_encoder(codec->ffmpeg_id);
1008 if(!codec->encoder[current_field])
1009 {
1010 printf("encode: avcodec_find_encoder returned NULL.\n");
1011 pthread_mutex_unlock(&ffmpeg_lock);
1012 return 1;
1013 }
1014
1015 codec->encoder_context[current_field] = avcodec_alloc_context();
1016 AVCodecContext *context = codec->encoder_context[current_field];
1017
1018 context->width = width_i;
1019 context->height = height_i;
1020 context->gop_size = codec->gop_size;
1021 context->pix_fmt = PIX_FMT_YUV420P;
1022 context->bit_rate = codec->bitrate / codec->total_fields;
1023 context->bit_rate_tolerance = codec->bitrate_tolerance;
1024 context->rc_eq = video_rc_eq;
1025 context->rc_max_rate = 0;
1026 context->rc_min_rate = 0;
1027 context->rc_buffer_size = 0;
1028 context->qmin =
1029 (!codec->fix_bitrate ? codec->quantizer : 2);
1030 context->qmax =
1031 (!codec->fix_bitrate ? codec->quantizer : 31);
1032 context->lmin = 2 * FF_QP2LAMBDA;
1033 context->lmax = 31 * FF_QP2LAMBDA;
1034 context->mb_lmin = 2 * FF_QP2LAMBDA;
1035 context->mb_lmax = 31 * FF_QP2LAMBDA;
1036 context->max_qdiff = 3;
1037 context->qblur = 0.5;
1038 context->qcompress = 0.5;
1039 // It needs the time per frame, not the frame rate.
1040 context->time_base.den = quicktime_frame_rate_n(file, track);
1041 context->time_base.num = quicktime_frame_rate_d(file, track);
1042
1043 context->b_quant_factor = 1.25;
1044 context->b_quant_offset = 1.25;
1045 context->error_resilience = FF_ER_CAREFULL;
1046 context->error_concealment = 3;
1047 context->frame_skip_cmp = FF_CMP_DCTMAX;
1048 context->ildct_cmp = FF_CMP_VSAD;
1049 context->intra_dc_precision = 0;
1050 context->intra_quant_bias = FF_DEFAULT_QUANT_BIAS;
1051 context->inter_quant_bias = FF_DEFAULT_QUANT_BIAS;
1052 context->i_quant_factor = -0.8;
1053 context->i_quant_offset = 0.0;
1054 context->mb_decision = FF_MB_DECISION_SIMPLE;
1055 context->mb_cmp = FF_CMP_SAD;
1056 context->me_sub_cmp = FF_CMP_SAD;
1057 context->me_cmp = FF_CMP_SAD;
1058 context->me_pre_cmp = FF_CMP_SAD;
1059 context->me_method = ME_EPZS;
1060 context->me_subpel_quality = 8;
1061 context->me_penalty_compensation = 256;
1062 context->me_range = 0;
1063 context->me_threshold = 0;
1064 context->mb_threshold = 0;
1065 context->nsse_weight= 8;
1066 context->profile= FF_PROFILE_UNKNOWN;
1067 context->rc_buffer_aggressivity = 1.0;
1068 context->level= FF_LEVEL_UNKNOWN;
1069 context->flags |= CODEC_FLAG_H263P_UMV;
1070 context->flags |= CODEC_FLAG_AC_PRED;
1071 context->flags |= CODEC_FLAG_4MV;
1072 // Not compatible with Win
1073 // context->flags |= CODEC_FLAG_QPEL;
1074
1075 if(file->cpus > 1)
1076 {
1077 avcodec_thread_init(context, file->cpus);
1078 context->thread_count = file->cpus;
1079 }
1080
1081 if(!codec->fix_bitrate)
1082 context->flags |= CODEC_FLAG_QSCALE;
1083
1084 if(codec->interlaced)
1085 {
1086 context->flags |= CODEC_FLAG_INTERLACED_DCT;
1087 context->flags |= CODEC_FLAG_INTERLACED_ME;
1088 }
1089
1090
1091 /*
1092 * printf("encode gop_size=%d fix_bitrate=%d quantizer=%d\n",
1093 * codec->gop_size,
1094 * codec->fix_bitrate,
1095 * codec->quantizer);
1096 */
1097 avcodec_open(context, codec->encoder[current_field]);
1098
1099 avcodec_get_frame_defaults(&codec->picture[current_field]);
1100
1101 }
1102 }
1103
1104
1105 if(!codec->work_buffer)
1106 {
1107 codec->buffer_size = width_i * height_i;
1108 codec->work_buffer = malloc(codec->buffer_size);
1109 }
1110
1111
1112
1113 // Encore section
1114 if(codec->use_encore)
1115 {
1116 // Encore section
1117 ENC_FRAME encore_input;
1118 ENC_RESULT encore_result;
1119
1120
1121 // Assume planes are contiguous.
1122 // Encode directly from function arguments
1123 if(file->color_model == BC_YUV420P &&
1124 width == width_i &&
1125 height == height_i)
1126 {
1127 encore_input.image = row_pointers[0];
1128 }
1129 // Convert to YUV420P
1130 // Encode from temporary.
1131 else
1132 {
1133 if(!codec->temp_frame)
1134 {
1135 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
1136 }
1137
1138 cmodel_transfer(0, /* Leave NULL if non existent */
1139 row_pointers,
1140 codec->temp_frame, /* Leave NULL if non existent */
1141 codec->temp_frame + width_i * height_i,
1142 codec->temp_frame + width_i * height_i + width_i * height_i / 4,
1143 row_pointers[0], /* Leave NULL if non existent */
1144 row_pointers[1],
1145 row_pointers[2],
1146 0, /* Dimensions to capture from input frame */
1147 0,
1148 width,
1149 height,
1150 0, /* Dimensions to project on output frame */
1151 0,
1152 width,
1153 height,
1154 file->color_model,
1155 BC_YUV420P,
1156 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
1157 width, /* For planar use the luma rowspan */
1158 width_i);
1159
1160
1161 encore_input.image = codec->temp_frame;
1162 }
1163
1164
1165
1166 bzero(codec->work_buffer, codec->buffer_size);
1167 encore_input.bitstream = codec->work_buffer;
1168 encore_input.length = 0;
1169 encore_input.quant = !codec->fix_bitrate ? codec->quantizer : 0;
1170
1171 if(codec->p_count == 0)
1172 {
1173 codec->p_count[current_field]++;
1174 }
1175 else
1176 {
1177 codec->p_count[current_field]++;
1178 if(codec->p_count[current_field] >= codec->max_key_interval)
1179 codec->p_count[current_field] = 0;
1180 }
1181
1182
1183 encore(codec->encode_handle[current_field],
1184 0,
1185 &encore_input,
1186 &encore_result);
1187
1188 bytes = encore_input.length;
1189 is_keyframe = encore_result.isKeyFrame;
1190 }
1191 else
1192 // ffmpeg section
1193 {
1194 AVCodecContext *context = codec->encoder_context[current_field];
1195 AVFrame *picture = &codec->picture[current_field];
1196
1197 if(width_i == width &&
1198 height_i == height &&
1199 file->color_model == BC_YUV420P)
1200 {
1201 picture->data[0] = row_pointers[0];
1202 picture->data[1] = row_pointers[1];
1203 picture->data[2] = row_pointers[2];
1204 picture->linesize[0] = width_i;
1205 picture->linesize[1] = width_i / 2;
1206 picture->linesize[2] = width_i / 2;
1207 }
1208 else
1209 {
1210 if(!codec->temp_frame)
1211 {
1212 codec->temp_frame = malloc(width_i * height_i * 3 / 2);
1213 }
1214
1215 cmodel_transfer(0, /* Leave NULL if non existent */
1216 row_pointers,
1217 codec->temp_frame, /* Leave NULL if non existent */
1218 codec->temp_frame + width_i * height_i,
1219 codec->temp_frame + width_i * height_i + width_i * height_i / 4,
1220 row_pointers[0], /* Leave NULL if non existent */
1221 row_pointers[1],
1222 row_pointers[2],
1223 0, /* Dimensions to capture from input frame */
1224 0,
1225 width,
1226 height,
1227 0, /* Dimensions to project on output frame */
1228 0,
1229 width,
1230 height,
1231 file->color_model,
1232 BC_YUV420P,
1233 0, /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
1234 width, /* For planar use the luma rowspan */
1235 width_i);
1236
1237 picture->data[0] = codec->temp_frame;
1238 picture->data[1] = codec->temp_frame + width_i * height_i;
1239 picture->data[2] = codec->temp_frame + width_i * height_i + width_i * height_i / 4;
1240 picture->linesize[0] = width_i;
1241 picture->linesize[1] = width_i / 2;
1242 picture->linesize[2] = width_i / 2;
1243 }
1244
1245
1246 picture->pict_type = 0;
1247 picture->quality = 0;
1248 picture->pts = vtrack->current_position * quicktime_frame_rate_d(file, track);
1249 picture->key_frame = 0;
1250 bytes = avcodec_encode_video(context,
1251 codec->work_buffer,
1252 codec->buffer_size,
1253 picture);
1254 is_keyframe = context->coded_frame && context->coded_frame->key_frame;
1255 /*
1256 * printf("encode current_position=%d is_keyframe=%d\n",
1257 * vtrack->current_position,
1258 * is_keyframe);
1259 */
1260
1261 if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
1262 !strcmp(((quicktime_codec_t*)vtrack->codec)->fourcc, QUICKTIME_MP4V))
1263 {
1264 unsigned char temp[1024];
1265 unsigned char *ptr = temp;
1266 for(i = 0; i < bytes - 4; i++)
1267 {
1268 if(!(codec->work_buffer[i] == 0x00 &&
1269 codec->work_buffer[i + 1] == 0x00 &&
1270 codec->work_buffer[i + 2] == 0x01 &&
1271 codec->work_buffer[i + 3] == 0xb3))
1272 {
1273 *ptr++ = codec->work_buffer[i];
1274 }
1275 else
1276 break;
1277 }
1278 quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0],
1279 temp,
1280 ptr - temp);
1281 trak->mdia.minf.stbl.stsd.table[0].version = 0;
1282 }
1283 }
1284
1285
1286
1287
1288
1289
1290 pthread_mutex_unlock(&ffmpeg_lock);
1291 quicktime_write_chunk_header(file, trak, &chunk_atom);
1292 result = !quicktime_write_data(file,
1293 codec->work_buffer,
1294 bytes);
1295 quicktime_write_chunk_footer(file,
1296 trak,
1297 vtrack->current_chunk,
1298 &chunk_atom,
1299 1);
1300 if(is_keyframe || vtrack->current_position == 0)
1301 quicktime_insert_keyframe(file,
1302 vtrack->current_position,
1303 track);
1304
1305 vtrack->current_chunk++;
1306 return result;
1307 }
1308
1309
1310
1311
1312
1313
1314 static void flush(quicktime_t *file, int track)
1315 {
1316 quicktime_video_map_t *track_map = &(file->vtracks[track]);
1317 quicktime_trak_t *trak = track_map->track;
1318 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)track_map->codec)->priv;
1319
1320 // Create header
1321 if(!trak->mdia.minf.stbl.stsd.table[0].esds.mpeg4_header_size &&
1322 !strcmp(((quicktime_codec_t*)track_map->codec)->fourcc, QUICKTIME_MP4V))
1323 {
1324 int width = trak->tkhd.track_width;
1325 int height = trak->tkhd.track_height;
1326 int width_i = quicktime_quantize16(width);
1327 int height_i = quicktime_quantize16(height);
1328
1329 unsigned char temp[1024];
1330 int size = write_mp4v_header(temp,
1331 width_i,
1332 height_i,
1333 quicktime_frame_rate(file, track));
1334 quicktime_set_mpeg4_header(&trak->mdia.minf.stbl.stsd.table[0],
1335 temp,
1336 size);
1337 }
1338
1339 // Create udta
1340 file->moov.udta.require = strdup("QuickTime 6.0 or greater");
1341 file->moov.udta.require_len = strlen(file->moov.udta.require);
1342 }
1343
1344
1345
1346
1347
1348
1349
1350
1351 static int set_parameter(quicktime_t *file,
1352 int track,
1353 char *key,
1354 void *value)
1355 {
1356 quicktime_video_map_t *vtrack = &(file->vtracks[track]);
1357 char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
1358
1359 if(quicktime_match_32(compressor, QUICKTIME_DIVX) ||
1360 quicktime_match_32(compressor, QUICKTIME_MP42) ||
1361 quicktime_match_32(compressor, QUICKTIME_MPG4) ||
1362 quicktime_match_32(compressor, QUICKTIME_DX50) ||
1363 quicktime_match_32(compressor, QUICKTIME_HV60))
1364 {
1365 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1366
1367 if(!strcasecmp(key, "divx_bitrate"))
1368 codec->bitrate = *(int*)value;
1369 else
1370 if(!strcasecmp(key, "divx_rc_period"))
1371 codec->rc_period = *(int*)value;
1372 else
1373 if(!strcasecmp(key, "divx_rc_reaction_ratio"))
1374 codec->rc_reaction_ratio = *(int*)value;
1375 else
1376 if(!strcasecmp(key, "divx_rc_reaction_period"))
1377 codec->rc_reaction_period = *(int*)value;
1378 else
1379 if(!strcasecmp(key, "divx_max_key_interval"))
1380 codec->max_key_interval = *(int*)value;
1381 else
1382 if(!strcasecmp(key, "divx_max_quantizer"))
1383 codec->max_quantizer = *(int*)value;
1384 else
1385 if(!strcasecmp(key, "divx_min_quantizer"))
1386 codec->min_quantizer = *(int*)value;
1387 else
1388 if(!strcasecmp(key, "divx_quantizer"))
1389 codec->quantizer = *(int*)value;
1390 else
1391 if(!strcasecmp(key, "divx_quality"))
1392 codec->quality = *(int*)value;
1393 else
1394 if(!strcasecmp(key, "divx_fix_bitrate"))
1395 codec->fix_bitrate = *(int*)value;
1396 else
1397 if(!strcasecmp(key, "divx_use_deblocking"))
1398 codec->use_deblocking = *(int*)value;
1399 }
1400 else
1401 if(quicktime_match_32(compressor, QUICKTIME_DIV3) ||
1402 quicktime_match_32(compressor, QUICKTIME_MP4V))
1403 {
1404 quicktime_mpeg4_codec_t *codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1405 if(!strcasecmp(key, "ffmpeg_bitrate"))
1406 codec->bitrate = *(int*)value;
1407 else
1408 if(!strcasecmp(key, "ffmpeg_bitrate_tolerance"))
1409 codec->bitrate_tolerance = *(int*)value;
1410 else
1411 if(!strcasecmp(key, "ffmpeg_interlaced"))
1412 codec->interlaced = *(int*)value;
1413 else
1414 if(!strcasecmp(key, "ffmpeg_gop_size"))
1415 codec->gop_size = *(int*)value;
1416 else
1417 if(!strcasecmp(key, "ffmpeg_quantizer"))
1418 codec->quantizer = *(int*)value;
1419 else
1420 if(!strcasecmp(key, "ffmpeg_fix_bitrate"))
1421 codec->fix_bitrate = *(int*)value;
1422 }
1423 return 0;
1424 }
1425
1426
1427
1428 static int delete_codec(quicktime_video_map_t *vtrack)
1429 {
1430 quicktime_mpeg4_codec_t *codec;
1431 int i;
1432
1433
1434 codec = ((quicktime_codec_t*)vtrack->codec)->priv;
1435 for(i = 0; i < codec->total_fields; i++)
1436 {
1437 if(codec->encode_initialized[i])
1438 {
1439 pthread_mutex_lock(&ffmpeg_lock);
1440 if(codec->use_encore)
1441 {
1442 encore(codec->encode_handle[i],
1443 ENC_OPT_RELEASE,
1444 0,
1445 0);
1446 }
1447 else
1448 {
1449 avcodec_close(codec->encoder_context[i]);
1450 free(codec->encoder_context[i]);
1451 }
1452 pthread_mutex_unlock(&ffmpeg_lock);
1453 }
1454 delete_decoder(codec, i);
1455 }
1456
1457
1458 if(codec->temp_frame) free(codec->temp_frame);
1459 if(codec->work_buffer) free(codec->work_buffer);
1460
1461
1462 free(codec);
1463 return 0;
1464 }
1465
1466
1467
1468
1469 static quicktime_mpeg4_codec_t* init_common(quicktime_video_map_t *vtrack,
1470 char *compressor,
1471 char *title,
1472 char *description)
1473 {
1474 quicktime_codec_t *codec_base = (quicktime_codec_t*)vtrack->codec;
1475 quicktime_mpeg4_codec_t *codec;
1476
1477 codec_base->priv = calloc(1, sizeof(quicktime_mpeg4_codec_t));
1478 codec_base->delete_vcodec = delete_codec;
1479 codec_base->decode_video = decode;
1480 codec_base->encode_video = encode;
1481 codec_base->flush = flush;
1482 codec_base->reads_colormodel = reads_colormodel;
1483 codec_base->writes_colormodel = writes_colormodel;
1484 codec_base->set_parameter = set_parameter;
1485 codec_base->fourcc = compressor;
1486 codec_base->title = title;
1487 codec_base->desc = description;
1488
1489 codec = (quicktime_mpeg4_codec_t*)codec_base->priv;
1490
1491
1492
1493 // Set defaults
1494 codec->bitrate = 1000000;
1495 codec->rc_period = 50;
1496 codec->rc_reaction_ratio = 45;
1497 codec->rc_reaction_period = 10;
1498 codec->max_key_interval = 45;
1499 codec->max_quantizer = 31;
1500 codec->min_quantizer = 1;
1501 codec->quantizer = 10;
1502 codec->quality = 5;
1503 codec->fix_bitrate = 1;
1504 codec->total_fields = 1;
1505
1506
1507
1508 return codec;
1509 }
1510
1511
1512
1513
1514 // Mike Rowe Soft MPEG-4
1515 void quicktime_init_codec_div3(quicktime_video_map_t *vtrack)
1516 {
1517 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1518 QUICKTIME_DIV3,
1519 "DIVX",
1520 "Mike Row Soft MPEG4 Version 3");
1521 result->ffmpeg_id = CODEC_ID_MSMPEG4V3;
1522 }
1523
1524 void quicktime_init_codec_div5(quicktime_video_map_t *vtrack)
1525 {
1526 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1527 QUICKTIME_DX50,
1528 "DIVX",
1529 "Mike Row Soft MPEG4 Version 5");
1530 result->ffmpeg_id = CODEC_ID_MPEG4;
1531 }
1532
1533 // Mike Rowe Soft MPEG-4
1534 void quicktime_init_codec_div3lower(quicktime_video_map_t *vtrack)
1535 {
1536 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1537 QUICKTIME_DIV3_LOWER,
1538 "DIVX",
1539 "Mike Row Soft MPEG4 Version 3");
1540 result->ffmpeg_id = CODEC_ID_MSMPEG4V3;
1541 }
1542
1543 void quicktime_init_codec_div3v2(quicktime_video_map_t *vtrack)
1544 {
1545 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1546 QUICKTIME_MP42,
1547 "MP42",
1548 "Mike Row Soft MPEG4 Version 2");
1549 result->ffmpeg_id = CODEC_ID_MSMPEG4V2;
1550 }
1551
1552 // Generic MPEG-4
1553 void quicktime_init_codec_divx(quicktime_video_map_t *vtrack)
1554 {
1555 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1556 QUICKTIME_DIVX,
1557 "MPEG-4",
1558 "Generic MPEG Four");
1559 result->ffmpeg_id = CODEC_ID_MPEG4;
1560 result->use_encore = 1;
1561 }
1562
1563 void quicktime_init_codec_mpg4(quicktime_video_map_t *vtrack)
1564 {
1565 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1566 QUICKTIME_MPG4,
1567 "MPEG-4",
1568 "FFMPEG (msmpeg4)");
1569 result->ffmpeg_id = CODEC_ID_MSMPEG4V1;
1570 }
1571
1572 void quicktime_init_codec_dx50(quicktime_video_map_t *vtrack)
1573 {
1574 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1575 QUICKTIME_DX50,
1576 "MPEG-4",
1577 "FFMPEG (mpeg4)");
1578 result->ffmpeg_id = CODEC_ID_MPEG4;
1579 }
1580
1581 // Generic MPEG-4
1582 void quicktime_init_codec_mp4v(quicktime_video_map_t *vtrack)
1583 {
1584 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1585 QUICKTIME_MP4V,
1586 "MPEG4",
1587 "Generic MPEG Four");
1588 result->ffmpeg_id = CODEC_ID_MPEG4;
1589 // result->use_encore = 1;
1590 }
1591
1592
1593 // Mormon MPEG-4
1594 void quicktime_init_codec_svq1(quicktime_video_map_t *vtrack)
1595 {
1596 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1597 QUICKTIME_SVQ1,
1598 "Sorenson Version 1",
1599 "From the chearch of codecs of yesterday's sights");
1600 result->ffmpeg_id = CODEC_ID_SVQ1;
1601 }
1602
1603 void quicktime_init_codec_svq3(quicktime_video_map_t *vtrack)
1604 {
1605 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1606 QUICKTIME_SVQ3,
1607 "Sorenson Version 3",
1608 "From the chearch of codecs of yesterday's sights");
1609 result->ffmpeg_id = CODEC_ID_SVQ3;
1610 }
1611
1612 void quicktime_init_codec_h263(quicktime_video_map_t *vtrack)
1613 {
1614 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1615 QUICKTIME_H263,
1616 "H.263",
1617 "H.263");
1618 result->ffmpeg_id = CODEC_ID_H263;
1619 }
1620
1621 void quicktime_init_codec_xvid(quicktime_video_map_t *vtrack)
1622 {
1623 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1624 QUICKTIME_XVID,
1625 "XVID",
1626 "FFmpeg MPEG-4");
1627 result->ffmpeg_id = CODEC_ID_MPEG4;
1628 }
1629
1630 // field based MPEG-4
1631 void quicktime_init_codec_hv60(quicktime_video_map_t *vtrack)
1632 {
1633 quicktime_mpeg4_codec_t *result = init_common(vtrack,
1634 QUICKTIME_HV60,
1635 "Dual MPEG-4",
1636 "MPEG 4 with alternating streams every other frame. (Not standardized)");
1637 result->total_fields = 2;
1638 result->ffmpeg_id = CODEC_ID_MPEG4;
1639 }
1640
1641
1642
1643
1644
1645
mob repository