Mercurial > mplayer.hg
annotate libmpdemux/video.c @ 12925:2abd8e24eb69
10l to the author of this longstanding and obscure bug. Each language
should be removed only once from the list.
Thanks to Chris White for pointing out that there was a problem.
author | diego |
---|---|
date | Sat, 31 Jul 2004 22:17:23 +0000 |
parents | 8db1b587d16a |
children | 7ac60a1c576e |
rev | line source |
---|---|
2567 | 1 // read video frame |
2 | |
2775 | 3 #include "config.h" |
4 | |
2567 | 5 #include <stdio.h> |
2775 | 6 #ifdef HAVE_MALLOC_H |
7 #include <malloc.h> | |
8 #endif | |
2567 | 9 #include <stdlib.h> |
3726 | 10 #include <string.h> |
2567 | 11 #include <unistd.h> |
12 | |
13 #include "mp_msg.h" | |
14 #include "help_mp.h" | |
15 | |
16 #include "stream.h" | |
17 #include "demuxer.h" | |
18 #include "stheader.h" | |
19 #include "parse_es.h" | |
20 #include "mpeg_hdr.h" | |
21 | |
6784
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
22 /* sub_cc (closed captions)*/ |
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
23 #include "../sub_cc.h" |
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
24 |
4774
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
25 /* biCompression constant */ |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
26 #define BI_RGB 0L |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
27 |
9457
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
28 #ifdef STREAMING_LIVE_DOT_COM |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
29 #include "demux_rtp.h" |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
30 #endif |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
31 |
2567 | 32 static mp_mpeg_header_t picture; |
33 | |
8967 | 34 static int telecine=0; |
35 static float telecine_cnt=-2.5; | |
36 | |
2567 | 37 int video_read_properties(sh_video_t *sh_video){ |
38 demux_stream_t *d_video=sh_video->ds; | |
39 | |
40 // Determine image properties: | |
41 switch(d_video->demuxer->file_format){ | |
42 case DEMUXER_TYPE_AVI: | |
43 case DEMUXER_TYPE_ASF: { | |
4774
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
44 // display info: |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
45 |
5898 | 46 #if 0 |
4774
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
47 if(sh_video->bih->biCompression == BI_RGB && |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
48 (sh_video->video.fccHandler == mmioFOURCC('D', 'I', 'B', ' ') || |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
49 sh_video->video.fccHandler == mmioFOURCC('R', 'G', 'B', ' ') || |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
50 sh_video->video.fccHandler == mmioFOURCC('R', 'A', 'W', ' ') || |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
51 sh_video->video.fccHandler == 0)) { |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
52 sh_video->format = mmioFOURCC(0, 'R', 'G', 'B') | sh_video->bih->biBitCount; |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
53 } |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
54 else |
5898 | 55 #endif |
4774
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
56 sh_video->format=sh_video->bih->biCompression; |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
57 |
2567 | 58 sh_video->disp_w=sh_video->bih->biWidth; |
59 sh_video->disp_h=abs(sh_video->bih->biHeight); | |
3980
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
60 |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
61 #if 1 |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
62 /* hack to support decoding of mpeg1 chunks in AVI's with libmpeg2 -- 2002 alex */ |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
63 if ((sh_video->format == 0x10000001) || |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
64 (sh_video->format == 0x10000002) || |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
65 (sh_video->format == mmioFOURCC('m','p','g','1')) || |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
66 (sh_video->format == mmioFOURCC('M','P','G','1')) || |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
67 (sh_video->format == mmioFOURCC('m','p','g','2')) || |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
68 (sh_video->format == mmioFOURCC('M','P','G','2')) || |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
69 (sh_video->format == mmioFOURCC('m','p','e','g')) || |
7302
7d32189dbae4
typo (checking for mpeg twice, instead of mpeg & MPEG)
michael
parents:
7208
diff
changeset
|
70 (sh_video->format == mmioFOURCC('M','P','E','G'))) |
3980
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
71 { |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
72 int saved_pos, saved_type; |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
73 |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
74 /* demuxer pos saving is required for libavcodec mpeg decoder as it's |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
75 reading the mpeg header self! */ |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
76 |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
77 saved_pos = d_video->buffer_pos; |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
78 saved_type = d_video->demuxer->file_format; |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
79 |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
80 d_video->demuxer->file_format = DEMUXER_TYPE_MPEG_ES; |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
81 video_read_properties(sh_video); |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
82 d_video->demuxer->file_format = saved_type; |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
83 d_video->buffer_pos = saved_pos; |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
84 // goto mpeg_header_parser; |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
85 } |
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
86 #endif |
2567 | 87 break; |
88 } | |
10687
f8d6f7d59ceb
- initial support for MPEG4 in TS (M4V is working, but not AAC yet)
arpi
parents:
10434
diff
changeset
|
89 case DEMUXER_TYPE_MPEG4_ES: |
f8d6f7d59ceb
- initial support for MPEG4 in TS (M4V is working, but not AAC yet)
arpi
parents:
10434
diff
changeset
|
90 case DEMUXER_TYPE_MPEG4_IN_TS: { |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
91 videobuf_len=0; videobuf_code_len=0; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
92 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Start code... ");fflush(stdout); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
93 while(1){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
94 int i=sync_video_packet(d_video); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
95 if(i<=0x11F) break; // found it! |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
96 if(!i || !skip_video_packet(d_video)){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
97 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
98 return 0; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
99 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
100 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
101 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
102 if(!videobuffer) videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
103 if(!videobuffer){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
104 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
105 return 0; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
106 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
107 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Layer Start code... ");fflush(stdout); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
108 while(1){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
109 int i=sync_video_packet(d_video); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
110 printf("0x%X\n",i); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
111 if(i>=0x120 && i<=0x12F) break; // found it! |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
112 if(!i || !read_video_packet(d_video)){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
113 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
114 return 0; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
115 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
116 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
117 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\nSearching for Video Object Plane Start code... ");fflush(stdout); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
118 while(1){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
119 int i=sync_video_packet(d_video); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
120 if(i==0x1B6) break; // found it! |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
121 if(!i || !read_video_packet(d_video)){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
122 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
123 return 0; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
124 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
125 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
126 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
127 sh_video->format=0x10000004; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
128 break; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
129 } |
9824 | 130 case DEMUXER_TYPE_H264_ES: { |
131 videobuf_len=0; videobuf_code_len=0; | |
132 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence parameter set... ");fflush(stdout); | |
133 while(1){ | |
134 int i=sync_video_packet(d_video); | |
135 if((i&~0x60) == 0x107 && i != 0x107) break; // found it! | |
136 if(!i || !skip_video_packet(d_video)){ | |
137 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); | |
138 return 0; | |
139 } | |
140 } | |
141 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); | |
142 if(!videobuffer) videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE); | |
143 if(!videobuffer){ | |
144 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail); | |
145 return 0; | |
146 } | |
147 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for picture parameter set... ");fflush(stdout); | |
148 while(1){ | |
149 int i=sync_video_packet(d_video); | |
150 printf("0x%X\n",i); | |
151 if((i&~0x60) == 0x108 && i != 0x108) break; // found it! | |
152 if(!i || !read_video_packet(d_video)){ | |
153 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); | |
154 return 0; | |
155 } | |
156 } | |
157 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\nSearching for Slice... ");fflush(stdout); | |
158 while(1){ | |
159 int i=sync_video_packet(d_video); | |
160 if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105) break; // found it! | |
161 if(!i || !read_video_packet(d_video)){ | |
162 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); | |
163 return 0; | |
164 } | |
165 } | |
166 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); | |
167 sh_video->format=0x10000005; | |
168 break; | |
169 } | |
9457
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
170 #ifdef STREAMING_LIVE_DOT_COM |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
171 case DEMUXER_TYPE_RTP: |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
172 // If the RTP stream is a MPEG stream, then we use this code to check |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
173 // for MPEG headers: |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
174 if (!demux_is_mpeg_rtp_stream(d_video->demuxer)) break; |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
175 // otherwise fall through to... |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
176 #endif |
7364
b2445802532c
.PVA (mpeg-like fileformat used by MultiDec && WinTV) demuxer
arpi
parents:
7302
diff
changeset
|
177 case DEMUXER_TYPE_PVA: |
9610 | 178 case DEMUXER_TYPE_MPEG_TS: |
2567 | 179 case DEMUXER_TYPE_MPEG_ES: |
10263 | 180 case DEMUXER_TYPE_MPEG_TY: |
2567 | 181 case DEMUXER_TYPE_MPEG_PS: { |
3980
cdd55ab40363
libmpeg2 is now able to decode framecopied (with mencoder) mpeg files
alex
parents:
3726
diff
changeset
|
182 //mpeg_header_parser: |
2567 | 183 // Find sequence_header first: |
184 videobuf_len=0; videobuf_code_len=0; | |
8967 | 185 telecine=0; telecine_cnt=-2.5; |
2567 | 186 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence header... ");fflush(stdout); |
187 while(1){ | |
188 int i=sync_video_packet(d_video); | |
189 if(i==0x1B3) break; // found it! | |
190 if(!i || !skip_video_packet(d_video)){ | |
8027 | 191 if(verbose>0) mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
2567 | 192 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_MpegNoSequHdr); |
193 return 0; | |
194 } | |
195 } | |
196 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); | |
197 // sh_video=d_video->sh;sh_video->ds=d_video; | |
198 // mpeg2_init(); | |
199 // ========= Read & process sequence header & extension ============ | |
200 if(!videobuffer) videobuffer=(char*)memalign(8,VIDEOBUFFER_SIZE); | |
201 if(!videobuffer){ | |
202 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail); | |
203 return 0; | |
204 } | |
205 | |
206 if(!read_video_packet(d_video)){ | |
207 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdr); | |
208 return 0; | |
209 } | |
210 if(mp_header_process_sequence_header (&picture, &videobuffer[4])) { | |
211 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdr); | |
212 return 0; | |
213 } | |
214 if(sync_video_packet(d_video)==0x1B5){ // next packet is seq. ext. | |
215 // videobuf_len=0; | |
216 int pos=videobuf_len; | |
217 if(!read_video_packet(d_video)){ | |
218 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdrEx); | |
219 return 0; | |
220 } | |
221 if(mp_header_process_extension (&picture, &videobuffer[pos+4])) { | |
222 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdrEx); | |
223 return 0; | |
224 } | |
225 } | |
226 | |
227 // printf("picture.fps=%d\n",picture.fps); | |
228 | |
229 // fill aspect info: | |
230 switch(picture.aspect_ratio_information){ | |
231 case 2: // PAL/NTSC SVCD/DVD 4:3 | |
232 case 8: // PAL VCD 4:3 | |
233 case 12: // NTSC VCD 4:3 | |
234 sh_video->aspect=4.0/3.0; | |
235 break; | |
236 case 3: // PAL/NTSC Widescreen SVCD/DVD 16:9 | |
3666 | 237 case 6: // (PAL?)/NTSC Widescreen SVCD 16:9 |
2567 | 238 sh_video->aspect=16.0/9.0; |
239 break; | |
11833 | 240 case 4: // according to ISO-138182-2 Table 6.3 |
241 sh_video->aspect=2.21; | |
242 break; | |
4336 | 243 case 9: // Movie Type ??? / 640x480 |
244 sh_video->aspect=0.0; | |
245 break; | |
2567 | 246 default: |
247 fprintf(stderr,"Detected unknown aspect_ratio_information in mpeg sequence header.\n" | |
248 "Please report the aspect value (%i) along with the movie type (VGA,PAL,NTSC," | |
249 "SECAM) and the movie resolution (720x576,352x240,480x480,...) to the MPlayer" | |
250 " developers, so that we can add support for it!\nAssuming 1:1 aspect for now.\n", | |
251 picture.aspect_ratio_information); | |
252 case 1: // VGA 1:1 - do not prescale | |
253 sh_video->aspect=0.0; | |
254 break; | |
255 } | |
256 // display info: | |
257 sh_video->format=picture.mpeg1?0x10000001:0x10000002; // mpeg video | |
258 sh_video->fps=picture.fps*0.0001f; | |
259 if(!sh_video->fps){ | |
260 // if(!force_fps){ | |
261 // fprintf(stderr,"FPS not specified (or invalid) in the header! Use the -fps option!\n"); | |
262 // return 0; | |
263 // } | |
264 sh_video->frametime=0; | |
265 } else { | |
266 sh_video->frametime=10000.0f/(float)picture.fps; | |
267 } | |
268 sh_video->disp_w=picture.display_picture_width; | |
269 sh_video->disp_h=picture.display_picture_height; | |
270 // bitrate: | |
271 if(picture.bitrate!=0x3FFFF) // unspecified/VBR ? | |
9606
0197c1e933fe
This patch corrects the calculation of the MPEG bitrate from the
arpi
parents:
9457
diff
changeset
|
272 sh_video->i_bps=picture.bitrate * 400 / 8; |
2567 | 273 // info: |
274 mp_dbg(MSGT_DECVIDEO,MSGL_DBG2,"mpeg bitrate: %d (%X)\n",picture.bitrate,picture.bitrate); | |
10709 | 275 mp_msg(MSGT_DECVIDEO,MSGL_INFO,"VIDEO: %s %dx%d (aspect %d) %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n", |
2567 | 276 picture.mpeg1?"MPEG1":"MPEG2", |
277 sh_video->disp_w,sh_video->disp_h, | |
278 picture.aspect_ratio_information, | |
279 sh_video->fps, | |
9606
0197c1e933fe
This patch corrects the calculation of the MPEG bitrate from the
arpi
parents:
9457
diff
changeset
|
280 sh_video->i_bps * 8 / 1000.0, |
0197c1e933fe
This patch corrects the calculation of the MPEG bitrate from the
arpi
parents:
9457
diff
changeset
|
281 sh_video->i_bps / 1000.0 ); |
2567 | 282 break; |
283 } | |
284 } // switch(file_format) | |
285 | |
286 return 1; | |
287 } | |
288 | |
10263 | 289 void ty_processuserdata( unsigned char* buf, int len ); |
290 | |
4074 | 291 static void process_userdata(unsigned char* buf,int len){ |
292 int i; | |
6791 | 293 /* if the user data starts with "CC", assume it is a CC info packet */ |
294 if(len>2 && buf[0]=='C' && buf[1]=='C'){ | |
295 // mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"video.c: process_userdata() detected Closed Captions!\n"); | |
6784
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
296 if(subcc_enabled) subcc_process_data(buf+2,len-2); |
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
297 } |
10263 | 298 if( len > 2 && buf[ 0 ] == 'T' && buf[ 1 ] == 'Y' ) |
299 { | |
300 ty_processuserdata( buf + 2, len - 2 ); | |
301 return; | |
302 } | |
7208 | 303 if(verbose<2) return; |
4074 | 304 printf( "user_data: len=%3d %02X %02X %02X %02X '", |
305 len, buf[0], buf[1], buf[2], buf[3]); | |
306 for(i=0;i<len;i++) | |
6791 | 307 // if(buf[i]>=32 && buf[i]<127) putchar(buf[i]); |
308 if(buf[i]&0x60) putchar(buf[i]&0x7F); | |
4074 | 309 printf("'\n"); |
310 } | |
311 | |
2567 | 312 int video_read_frame(sh_video_t* sh_video,float* frame_time_ptr,unsigned char** start,int force_fps){ |
313 demux_stream_t *d_video=sh_video->ds; | |
314 demuxer_t *demuxer=d_video->demuxer; | |
315 float frame_time=1; | |
316 float pts1=d_video->pts; | |
8965 | 317 float pts=0; |
318 int picture_coding_type=0; | |
2567 | 319 // unsigned char* start=NULL; |
320 int in_size=0; | |
321 | |
322 *start=NULL; | |
323 | |
6910
1a747aee653b
applied live.com streaming patch (-sdp and rtsp:// support) by Ross Finlayson <finlayson@live.com>
arpi
parents:
6791
diff
changeset
|
324 if(demuxer->file_format==DEMUXER_TYPE_MPEG_ES || demuxer->file_format==DEMUXER_TYPE_MPEG_PS |
9610 | 325 || demuxer->file_format==DEMUXER_TYPE_PVA || demuxer->file_format==DEMUXER_TYPE_MPEG_TS |
10263 | 326 || demuxer->file_format==DEMUXER_TYPE_MPEG_TY |
6910
1a747aee653b
applied live.com streaming patch (-sdp and rtsp:// support) by Ross Finlayson <finlayson@live.com>
arpi
parents:
6791
diff
changeset
|
327 #ifdef STREAMING_LIVE_DOT_COM |
1a747aee653b
applied live.com streaming patch (-sdp and rtsp:// support) by Ross Finlayson <finlayson@live.com>
arpi
parents:
6791
diff
changeset
|
328 || (demuxer->file_format==DEMUXER_TYPE_RTP && demux_is_mpeg_rtp_stream(demuxer)) |
1a747aee653b
applied live.com streaming patch (-sdp and rtsp:// support) by Ross Finlayson <finlayson@live.com>
arpi
parents:
6791
diff
changeset
|
329 #endif |
1a747aee653b
applied live.com streaming patch (-sdp and rtsp:// support) by Ross Finlayson <finlayson@live.com>
arpi
parents:
6791
diff
changeset
|
330 ){ |
2567 | 331 int in_frame=0; |
332 //float newfps; | |
333 //videobuf_len=0; | |
334 while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){ | |
335 int i=sync_video_packet(d_video); | |
4074 | 336 //void* buffer=&videobuffer[videobuf_len+4]; |
337 int start=videobuf_len+4; | |
2567 | 338 if(in_frame){ |
339 if(i<0x101 || i>=0x1B0){ // not slice code -> end of frame | |
7465 | 340 #if 0 |
2567 | 341 // send END OF FRAME code: |
342 videobuffer[videobuf_len+0]=0; | |
343 videobuffer[videobuf_len+1]=0; | |
344 videobuffer[videobuf_len+2]=1; | |
345 videobuffer[videobuf_len+3]=0xFF; | |
346 videobuf_len+=4; | |
347 #endif | |
348 if(!i) return -1; // EOF | |
349 break; | |
350 } | |
351 } else { | |
8965 | 352 if(i==0x100){ |
353 pts=d_video->pts; | |
354 d_video->pts=0; | |
355 } | |
2567 | 356 //if(i==0x100) in_frame=1; // picture startcode |
357 if(i>=0x101 && i<0x1B0) in_frame=1; // picture startcode | |
358 else if(!i) return -1; // EOF | |
359 } | |
360 //if(grab_frames==2 && (i==0x1B3 || i==0x1B8)) grab_frames=1; | |
361 if(!read_video_packet(d_video)) return -1; // EOF | |
362 //printf("read packet 0x%X, len=%d\n",i,videobuf_len); | |
363 // process headers: | |
364 switch(i){ | |
4074 | 365 case 0x1B3: mp_header_process_sequence_header (&picture, &videobuffer[start]);break; |
366 case 0x1B5: mp_header_process_extension (&picture, &videobuffer[start]);break; | |
6784
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
367 case 0x1B2: process_userdata (&videobuffer[start], videobuf_len-start);break; |
8965 | 368 case 0x100: picture_coding_type=(videobuffer[start+1] >> 3) & 7;break; |
2567 | 369 } |
370 } | |
371 | |
372 // if(videobuf_len>max_framesize) max_framesize=videobuf_len; // debug | |
373 //printf("--- SEND %d bytes\n",videobuf_len); | |
374 // if(grab_frames==1){ | |
375 // FILE *f=fopen("grab.mpg","ab"); | |
376 // fwrite(videobuffer,videobuf_len-4,1,f); | |
377 // fclose(f); | |
378 // } | |
379 | |
380 *start=videobuffer; in_size=videobuf_len; | |
381 //blit_frame=decode_video(video_out,sh_video,videobuffer,videobuf_len,drop_frame); | |
382 | |
383 #if 1 | |
384 // get mpeg fps: | |
385 //newfps=frameratecode2framerate[picture->frame_rate_code]*0.0001f; | |
8967 | 386 if((int)(sh_video->fps*10000+0.5)!=picture.fps) if(!force_fps && !telecine){ |
2567 | 387 mp_msg(MSGT_CPLAYER,MSGL_WARN,"Warning! FPS changed %5.3f -> %5.3f (%f) [%d] \n",sh_video->fps,picture.fps*0.0001,sh_video->fps-picture.fps*0.0001,picture.frame_rate_code); |
388 sh_video->fps=picture.fps*0.0001; | |
389 sh_video->frametime=10000.0f/(float)picture.fps; | |
390 } | |
391 #endif | |
392 | |
393 // fix mpeg2 frametime: | |
394 frame_time=(picture.display_time)*0.01f; | |
395 picture.display_time=100; | |
396 videobuf_len=0; | |
397 | |
8967 | 398 telecine_cnt*=0.9; // drift out error |
399 telecine_cnt+=frame_time-5.0/4.0; | |
9221 | 400 mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"\r telecine = %3.1f %5.3f \n",frame_time,telecine_cnt); |
8967 | 401 |
402 if(telecine){ | |
403 frame_time=1; | |
404 if(telecine_cnt<-1.5 || telecine_cnt>1.5){ | |
405 mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_LeaveTelecineMode); | |
406 telecine=0; | |
407 } | |
408 } else | |
409 if(telecine_cnt>-0.5 && telecine_cnt<0.5 && !force_fps){ | |
410 sh_video->fps=sh_video->fps*4/5; | |
411 sh_video->frametime=sh_video->frametime*5/4; | |
11385 | 412 mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_EnterTelecineMode); |
8967 | 413 telecine=1; |
414 } | |
415 | |
10687
f8d6f7d59ceb
- initial support for MPEG4 in TS (M4V is working, but not AAC yet)
arpi
parents:
10434
diff
changeset
|
416 } else if((demuxer->file_format==DEMUXER_TYPE_MPEG4_ES) || (demuxer->file_format==DEMUXER_TYPE_MPEG4_IN_TS)){ |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
417 // |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
418 while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
419 int i=sync_video_packet(d_video); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
420 if(!read_video_packet(d_video)) return -1; // EOF |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
421 if(i==0x1B6) break; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
422 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
423 *start=videobuffer; in_size=videobuf_len; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
424 videobuf_len=0; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
425 |
9824 | 426 } else if(demuxer->file_format==DEMUXER_TYPE_H264_ES){ |
427 // | |
428 while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){ | |
429 int i=sync_video_packet(d_video); | |
430 if(!read_video_packet(d_video)) return -1; // EOF | |
431 if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105) break; | |
432 } | |
433 *start=videobuffer; in_size=videobuf_len; | |
434 videobuf_len=0; | |
435 | |
2567 | 436 } else { |
437 // frame-based file formats: (AVI,ASF,MOV) | |
438 in_size=ds_get_packet(d_video,start); | |
439 if(in_size<0) return -1; // EOF | |
440 // if(in_size>max_framesize) max_framesize=in_size; | |
441 // blit_frame=decode_video(video_out,sh_video,start,in_size,drop_frame); | |
442 } | |
443 | |
444 // vdecode_time=video_time_usage-vdecode_time; | |
445 | |
446 //------------------------ frame decoded. -------------------- | |
447 | |
448 // Increase video timers: | |
449 sh_video->num_frames+=frame_time; | |
450 ++sh_video->num_frames_decoded; | |
451 | |
452 frame_time*=sh_video->frametime; | |
5573
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
453 |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
454 // override frame_time for variable/unknown FPS formats: |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
455 if(!force_fps) switch(demuxer->file_format){ |
9693
1d598bf65571
10l, found by Jan Kritzner <kritzner@informatik.rwth-aachen.de>
alex
parents:
9610
diff
changeset
|
456 case DEMUXER_TYPE_GIF: |
6423 | 457 case DEMUXER_TYPE_REAL: |
10434
dd64e1fe919d
Better support for RealVideo/RealAudio in Matroska. Includes the timestamp fixes from demux_real.c. Seeking is working. Added Matroska to the formats with variable FPS in video.c.
mosu
parents:
10263
diff
changeset
|
458 case DEMUXER_TYPE_MATROSKA: |
6423 | 459 if(d_video->pts>0 && pts1>0 && d_video->pts>pts1) |
460 frame_time=d_video->pts-pts1; | |
461 break; | |
6571 | 462 #ifdef USE_TV |
5573
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
463 case DEMUXER_TYPE_TV: |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
464 #endif |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
465 case DEMUXER_TYPE_MOV: |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
466 case DEMUXER_TYPE_FILM: |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
467 case DEMUXER_TYPE_VIVO: |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
468 case DEMUXER_TYPE_ASF: { |
5930
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5898
diff
changeset
|
469 float next_pts = ds_get_next_pts(d_video); |
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5898
diff
changeset
|
470 float d= next_pts > 0 ? next_pts - d_video->pts : d_video->pts-pts1; |
6371
622d57683187
Fix asf stream wich were giving invalid frame times because the frame time
albeu
parents:
5930
diff
changeset
|
471 if(d>=0){ |
6423 | 472 if(d>0){ |
2567 | 473 if((int)sh_video->fps==1000) |
6423 | 474 mp_msg(MSGT_CPLAYER,MSGL_V,"\navg. framerate: %d fps \n",(int)(1.0f/d)); |
475 sh_video->frametime=d; // 1ms | |
476 sh_video->fps=1.0f/d; | |
477 } | |
5930
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5898
diff
changeset
|
478 frame_time = d; |
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5898
diff
changeset
|
479 } else { |
6423 | 480 mp_msg(MSGT_CPLAYER,MSGL_WARN,"\nInvalid frame duration value (%5.3f/%5.3f => %5.3f). Defaulting to %5.3f sec.\n",d_video->pts,next_pts,d,frame_time); |
481 // frame_time = 1/25.0; | |
2567 | 482 } |
5573
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
483 } |
9693
1d598bf65571
10l, found by Jan Kritzner <kritzner@informatik.rwth-aachen.de>
alex
parents:
9610
diff
changeset
|
484 break; |
12170 | 485 case DEMUXER_TYPE_LAVF: |
486 if((int)sh_video->fps==1000 || (int)sh_video->fps<=1){ | |
487 float next_pts = ds_get_next_pts(d_video); | |
488 float d= next_pts > 0 ? next_pts - d_video->pts : d_video->pts-pts1; | |
489 if(d>=0){ | |
490 frame_time = d; | |
491 } | |
492 } | |
493 break; | |
2567 | 494 } |
5573
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
495 |
4705 | 496 if(demuxer->file_format==DEMUXER_TYPE_MPEG_PS || |
9610 | 497 demuxer->file_format==DEMUXER_TYPE_MPEG_TS || |
10263 | 498 demuxer->file_format==DEMUXER_TYPE_MPEG_ES || |
499 demuxer->file_format==DEMUXER_TYPE_MPEG_TY){ | |
8965 | 500 |
501 // if(pts>0.0001) printf("\r!!! pts: %5.3f [%d] (%5.3f) \n",pts,picture_coding_type,i_pts); | |
502 | |
503 sh_video->pts+=frame_time; | |
504 if(picture_coding_type<=2 && sh_video->i_pts){ | |
505 // printf("XXX predict: %5.3f pts: %5.3f error=%5.5f \n",i_pts,d_video->pts2,i_pts-d_video->pts2); | |
506 sh_video->pts=sh_video->i_pts; | |
507 sh_video->i_pts=pts; | |
508 } else { | |
509 if(pts){ | |
510 if(picture_coding_type<=2) sh_video->i_pts=pts; | |
511 else { | |
512 // printf("BBB predict: %5.3f pts: %5.3f error=%5.5f \n",pts,d_video->pts2,pts-d_video->pts2); | |
513 sh_video->pts=pts; | |
514 } | |
515 } | |
516 } | |
517 // printf("\rIII pts: %5.3f [%d] (%5.3f) \n",d_video->pts2,picture_coding_type,i_pts); | |
518 } else | |
519 sh_video->pts=d_video->pts; | |
2567 | 520 |
521 if(frame_time_ptr) *frame_time_ptr=frame_time; | |
522 return in_size; | |
523 | |
524 } | |
525 |