Mercurial > mplayer.hg
annotate libmpdemux/video.c @ 33259:04dc3e55cd90
Increase the maximum value of the DVB timeout to 240 seconds.
Some devices may need more time for the initial tune (e.g. firmware loading).
Let the user specify higher timeout value if there is need to.
The default remains 30 seconds.
author | iive |
---|---|
date | Sun, 01 May 2011 18:07:59 +0000 |
parents | ce9c41d97bfd |
children | 25667edae85c |
rev | line source |
---|---|
29238
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
1 /* |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
2 * video frame reading |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
3 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
4 * This file is part of MPlayer. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
5 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
6 * MPlayer is free software; you can redistribute it and/or modify |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
7 * it under the terms of the GNU General Public License as published by |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
8 * the Free Software Foundation; either version 2 of the License, or |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
9 * (at your option) any later version. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
10 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
11 * MPlayer is distributed in the hope that it will be useful, |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
14 * GNU General Public License for more details. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
15 * |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
16 * You should have received a copy of the GNU General Public License along |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
17 * with MPlayer; if not, write to the Free Software Foundation, Inc., |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
d643e4643313
Add standard license header to all files in libmpdemux.
diego
parents:
28594
diff
changeset
|
19 */ |
2567 | 20 |
2775 | 21 #include "config.h" |
22 | |
2567 | 23 #include <stdio.h> |
28594
df67d03dde3b
Convert HAVE_MALLOC_H into a 0/1 definition, fixes the warning:
diego
parents:
28018
diff
changeset
|
24 #if HAVE_MALLOC_H |
2775 | 25 #include <malloc.h> |
26 #endif | |
2567 | 27 #include <stdlib.h> |
3726 | 28 #include <string.h> |
2567 | 29 #include <unistd.h> |
30 | |
31 #include "mp_msg.h" | |
32 #include "help_mp.h" | |
33 | |
22605
4d81dbdf46b9
Add explicit location for headers from the stream/ directory.
diego
parents:
22173
diff
changeset
|
34 #include "stream/stream.h" |
2567 | 35 #include "demuxer.h" |
30577
737b7fd47ef4
Add header for ty_ClearOSD(), ty_processuserdata(); avoids forward declarations.
diego
parents:
29878
diff
changeset
|
36 #include "demux_ty_osd.h" |
2567 | 37 #include "stheader.h" |
38 #include "parse_es.h" | |
39 #include "mpeg_hdr.h" | |
40 | |
6784
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
41 /* sub_cc (closed captions)*/ |
32458 | 42 #include "sub/sub_cc.h" |
6784
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
43 |
4774
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
44 /* biCompression constant */ |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
45 #define BI_RGB 0L |
fc2f76964606
Patch: Improved raw encoding support in mencoder by Fredrik Kuivinen
atmos4
parents:
4705
diff
changeset
|
46 |
27397
d47744b95b78
Give a CONFIG_ prefix to preprocessor directives that lacked one and
diego
parents:
27282
diff
changeset
|
47 #ifdef CONFIG_LIVE555 |
9457
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
48 #include "demux_rtp.h" |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
49 #endif |
ea1c0a4520bf
Repairing breakage to RTP streaming. Patch by Ross Finlayson <finlayson@live.com>
bertrand
parents:
9221
diff
changeset
|
50 |
2567 | 51 static mp_mpeg_header_t picture; |
52 | |
8967 | 53 static int telecine=0; |
54 static float telecine_cnt=-2.5; | |
55 | |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
56 typedef enum { |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
57 VIDEO_MPEG12, |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
58 VIDEO_MPEG4, |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
59 VIDEO_H264, |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
60 VIDEO_VC1, |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
61 VIDEO_OTHER |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
62 } video_codec_t; |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
63 |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
64 static video_codec_t find_video_codec(sh_video_t *sh_video) |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
65 { |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
66 demux_stream_t *d_video=sh_video->ds; |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
67 int fmt = d_video->demuxer->file_format; |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
68 |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
69 if( |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
70 (fmt == DEMUXER_TYPE_PVA) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
71 (fmt == DEMUXER_TYPE_MPEG_ES) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
72 (fmt == DEMUXER_TYPE_MPEG_GXF) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
73 (fmt == DEMUXER_TYPE_MPEG_PES) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
74 ( |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
75 (fmt == DEMUXER_TYPE_MPEG_PS || fmt == DEMUXER_TYPE_MPEG_TS) && |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
76 ((! sh_video->format) || (sh_video->format==0x10000001) || (sh_video->format==0x10000002)) |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
77 ) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
78 (fmt == DEMUXER_TYPE_MPEG_TY) |
27397
d47744b95b78
Give a CONFIG_ prefix to preprocessor directives that lacked one and
diego
parents:
27282
diff
changeset
|
79 #ifdef CONFIG_LIVE555 |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
80 || ((fmt == DEMUXER_TYPE_RTP) && demux_is_mpeg_rtp_stream(d_video->demuxer)) |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
81 #endif |
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
82 ) |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
83 return VIDEO_MPEG12; |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
84 else if((fmt == DEMUXER_TYPE_MPEG4_ES) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
85 ((fmt == DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000004)) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
86 ((fmt == DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000004)) |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
87 ) |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
88 return VIDEO_MPEG4; |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
89 else if((fmt == DEMUXER_TYPE_H264_ES) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
90 ((fmt == DEMUXER_TYPE_MPEG_TS) && (sh_video->format==0x10000005)) || |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
91 ((fmt == DEMUXER_TYPE_MPEG_PS) && (sh_video->format==0x10000005)) |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
92 ) |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
93 return VIDEO_H264; |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
94 else if((fmt == DEMUXER_TYPE_MPEG_PS || fmt == DEMUXER_TYPE_MPEG_TS) && |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
95 (sh_video->format==mmioFOURCC('W', 'V', 'C', '1'))) |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
96 return VIDEO_VC1; |
26296
71ddd37be152
Do proper parsing for DVR-MS files, this fixes playback with ffmpeg decoder
reimar
parents:
26069
diff
changeset
|
97 else if (fmt == DEMUXER_TYPE_ASF && sh_video->bih && sh_video->bih->biCompression == mmioFOURCC('D', 'V', 'R', ' ')) |
71ddd37be152
Do proper parsing for DVR-MS files, this fixes playback with ffmpeg decoder
reimar
parents:
26069
diff
changeset
|
98 return VIDEO_MPEG12; |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
99 else |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
100 return VIDEO_OTHER; |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
101 } |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
102 |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
103 int video_read_properties(sh_video_t *sh_video){ |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
104 demux_stream_t *d_video=sh_video->ds; |
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
105 video_codec_t video_codec = find_video_codec(sh_video); |
2567 | 106 // Determine image properties: |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
107 switch(video_codec){ |
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
108 case VIDEO_OTHER: { |
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
109 if((d_video->demuxer->file_format == DEMUXER_TYPE_ASF) || (d_video->demuxer->file_format == DEMUXER_TYPE_AVI)) { |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
110 // display info: |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
111 // in case no strf chunk has been seen in avi, we have no bitmap header |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
112 if(!sh_video->bih) return 0; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
113 sh_video->format=sh_video->bih->biCompression; |
2567 | 114 sh_video->disp_w=sh_video->bih->biWidth; |
115 sh_video->disp_h=abs(sh_video->bih->biHeight); | |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
116 } |
2567 | 117 break; |
118 } | |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
119 case VIDEO_MPEG4: { |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
120 int pos = 0, vop_cnt=0, units[3]; |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
121 videobuf_len=0; videobuf_code_len=0; |
24838
a0181b13daf5
removed funny calls to fflush(stdout) after mp_msg()
nicodvb
parents:
24837
diff
changeset
|
122 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Start code... "); |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
123 while(1){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
124 int i=sync_video_packet(d_video); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
125 if(i<=0x11F) break; // found it! |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
126 if(!i || !skip_video_packet(d_video)){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
127 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
128 return 0; |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
129 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
130 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
131 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
132 if(!videobuffer) { |
32763
ce9c41d97bfd
Do not pointlessly cast the return value of memalign().
diego
parents:
32568
diff
changeset
|
133 videobuffer = memalign(8, VIDEOBUFFER_SIZE + MP_INPUT_BUFFER_PADDING_SIZE); |
27282
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27269
diff
changeset
|
134 if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, MP_INPUT_BUFFER_PADDING_SIZE); |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
135 else { |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
136 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail); |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
137 return 0; |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
138 } |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
139 } |
24838
a0181b13daf5
removed funny calls to fflush(stdout) after mp_msg()
nicodvb
parents:
24837
diff
changeset
|
140 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for Video Object Layer Start code... "); |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
141 while(1){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
142 int i=sync_video_packet(d_video); |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
143 mp_msg(MSGT_DECVIDEO,MSGL_V,"M4V: 0x%X\n",i); |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
144 if(i>=0x120 && i<=0x12F) break; // found it! |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
145 if(!i || !read_video_packet(d_video)){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
146 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
147 return 0; |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
148 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
149 } |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
150 pos = videobuf_len+4; |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
151 if(!read_video_packet(d_video)){ |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
152 mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read Video Object Layer Header\n"); |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
153 return 0; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
154 } |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
155 mp4_header_process_vol(&picture, &(videobuffer[pos])); |
24838
a0181b13daf5
removed funny calls to fflush(stdout) after mp_msg()
nicodvb
parents:
24837
diff
changeset
|
156 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK! FPS SEEMS TO BE %.3f\nSearching for Video Object Plane Start code... ", sh_video->fps); |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
157 mp4_init: |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
158 while(1){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
159 int i=sync_video_packet(d_video); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
160 if(i==0x1B6) break; // found it! |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
161 if(!i || !read_video_packet(d_video)){ |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
162 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
163 return 0; |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
164 } |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
165 } |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
166 pos = videobuf_len+4; |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
167 if(!read_video_packet(d_video)){ |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
168 mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read Video Object Plane Header\n"); |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
169 return 0; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
170 } |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
171 mp4_header_process_vop(&picture, &(videobuffer[pos])); |
30862
2a8e5cea0c8c
Calculate width and height in mp4_header_process_vop().
cehoyos
parents:
30702
diff
changeset
|
172 sh_video->disp_w = picture.display_picture_width; |
2a8e5cea0c8c
Calculate width and height in mp4_header_process_vop().
cehoyos
parents:
30702
diff
changeset
|
173 sh_video->disp_h = picture.display_picture_height; |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
174 units[vop_cnt] = picture.timeinc_unit; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
175 vop_cnt++; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
176 //mp_msg(MSGT_DECVIDEO,MSGL_V, "TYPE: %d, unit: %d\n", picture.picture_type, picture.timeinc_unit); |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
177 if(!picture.fps) { |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
178 int i, mn, md, mx, diff; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
179 if(vop_cnt < 3) |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
180 goto mp4_init; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
181 |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
182 i=0; |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
183 mn = mx = units[0]; |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
184 for(i=0; i<3; i++) { |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
185 if(units[i] < mn) |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
186 mn = units[i]; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
187 if(units[i] > mx) |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
188 mx = units[i]; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
189 } |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
190 md = mn; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
191 for(i=0; i<3; i++) { |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
192 if((units[i] > mn) && (units[i] < mx)) |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
193 md = units[i]; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
194 } |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
195 mp_msg(MSGT_DECVIDEO,MSGL_V, "MIN: %d, mid: %d, max: %d\n", mn, md, mx); |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
196 if(mx - md > md - mn) |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
197 diff = md - mn; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
198 else |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
199 diff = mx - md; |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
200 if(diff > 0){ |
16184
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
201 picture.fps = ((float)picture.timeinc_resolution) / diff; |
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
202 mp_msg(MSGT_DECVIDEO,MSGL_V, "FPS seems to be: %f, resolution: %d, delta_units: %d\n", picture.fps, picture.timeinc_resolution, diff); |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
203 } |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
204 } |
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
205 if(picture.fps) { |
16184
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
206 sh_video->fps=picture.fps; |
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
207 sh_video->frametime=1.0/picture.fps; |
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
208 mp_msg(MSGT_DECVIDEO,MSGL_INFO, "FPS seems to be: %f\n", picture.fps); |
14477
92553e3c8f01
automatic fps calculation for mpeg4 in raw stream/mpeg-ts
nicodvb
parents:
14034
diff
changeset
|
209 } |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
210 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
211 sh_video->format=0x10000004; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
212 break; |
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
213 } |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
214 case VIDEO_H264: { |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
215 int pos = 0; |
9824 | 216 videobuf_len=0; videobuf_code_len=0; |
24838
a0181b13daf5
removed funny calls to fflush(stdout) after mp_msg()
nicodvb
parents:
24837
diff
changeset
|
217 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence parameter set... "); |
9824 | 218 while(1){ |
219 int i=sync_video_packet(d_video); | |
220 if((i&~0x60) == 0x107 && i != 0x107) break; // found it! | |
221 if(!i || !skip_video_packet(d_video)){ | |
222 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
223 return 0; |
9824 | 224 } |
225 } | |
226 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); | |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
227 if(!videobuffer) { |
32763
ce9c41d97bfd
Do not pointlessly cast the return value of memalign().
diego
parents:
32568
diff
changeset
|
228 videobuffer = memalign(8, VIDEOBUFFER_SIZE + MP_INPUT_BUFFER_PADDING_SIZE); |
27282
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27269
diff
changeset
|
229 if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, MP_INPUT_BUFFER_PADDING_SIZE); |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
230 else { |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
231 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail); |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
232 return 0; |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
233 } |
9824 | 234 } |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
235 pos = videobuf_len+4; |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
236 if(!read_video_packet(d_video)){ |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
237 mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Can't read sequence parameter set\n"); |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
238 return 0; |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
239 } |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
240 h264_parse_sps(&picture, &(videobuffer[pos]), videobuf_len - pos); |
29878 | 241 sh_video->disp_w=picture.display_picture_width; |
242 sh_video->disp_h=picture.display_picture_height; | |
24838
a0181b13daf5
removed funny calls to fflush(stdout) after mp_msg()
nicodvb
parents:
24837
diff
changeset
|
243 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for picture parameter set... "); |
9824 | 244 while(1){ |
245 int i=sync_video_packet(d_video); | |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
246 mp_msg(MSGT_DECVIDEO,MSGL_V,"H264: 0x%X\n",i); |
9824 | 247 if((i&~0x60) == 0x108 && i != 0x108) break; // found it! |
248 if(!i || !read_video_packet(d_video)){ | |
249 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
250 return 0; |
9824 | 251 } |
252 } | |
24838
a0181b13daf5
removed funny calls to fflush(stdout) after mp_msg()
nicodvb
parents:
24837
diff
changeset
|
253 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\nSearching for Slice... "); |
9824 | 254 while(1){ |
255 int i=sync_video_packet(d_video); | |
256 if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105) break; // found it! | |
257 if(!i || !read_video_packet(d_video)){ | |
258 mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
259 return 0; |
9824 | 260 } |
261 } | |
262 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); | |
263 sh_video->format=0x10000005; | |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
264 if(picture.fps) { |
16184
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
265 sh_video->fps=picture.fps; |
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
266 sh_video->frametime=1.0/picture.fps; |
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
267 mp_msg(MSGT_DECVIDEO,MSGL_INFO, "FPS seems to be: %f\n", picture.fps); |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
268 } |
9824 | 269 break; |
270 } | |
14034
7ac60a1c576e
merged DEMUXER_TYPE_MPEG4_ES in the ordinary TS; added support for H264 in TS
nicodvb
parents:
12170
diff
changeset
|
271 case VIDEO_MPEG12: { |
26296
71ddd37be152
Do proper parsing for DVR-MS files, this fixes playback with ffmpeg decoder
reimar
parents:
26069
diff
changeset
|
272 if (d_video->demuxer->file_format == DEMUXER_TYPE_ASF) { // DVR-MS |
71ddd37be152
Do proper parsing for DVR-MS files, this fixes playback with ffmpeg decoder
reimar
parents:
26069
diff
changeset
|
273 if(!sh_video->bih) return 0; |
71ddd37be152
Do proper parsing for DVR-MS files, this fixes playback with ffmpeg decoder
reimar
parents:
26069
diff
changeset
|
274 sh_video->format=sh_video->bih->biCompression; |
71ddd37be152
Do proper parsing for DVR-MS files, this fixes playback with ffmpeg decoder
reimar
parents:
26069
diff
changeset
|
275 } |
17277
c568f01ef9f9
search next sequence_header untile a valid one is found
nicodvb
parents:
17226
diff
changeset
|
276 mpeg_header_parser: |
2567 | 277 // Find sequence_header first: |
278 videobuf_len=0; videobuf_code_len=0; | |
8967 | 279 telecine=0; telecine_cnt=-2.5; |
24838
a0181b13daf5
removed funny calls to fflush(stdout) after mp_msg()
nicodvb
parents:
24837
diff
changeset
|
280 mp_msg(MSGT_DECVIDEO,MSGL_V,"Searching for sequence header... "); |
2567 | 281 while(1){ |
282 int i=sync_video_packet(d_video); | |
283 if(i==0x1B3) break; // found it! | |
284 if(!i || !skip_video_packet(d_video)){ | |
17932 | 285 if( mp_msg_test(MSGT_DECVIDEO,MSGL_V) ) mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
2567 | 286 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_MpegNoSequHdr); |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
287 return 0; |
2567 | 288 } |
289 } | |
290 mp_msg(MSGT_DECVIDEO,MSGL_V,"OK!\n"); | |
291 // ========= Read & process sequence header & extension ============ | |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
292 if(!videobuffer) { |
32763
ce9c41d97bfd
Do not pointlessly cast the return value of memalign().
diego
parents:
32568
diff
changeset
|
293 videobuffer = memalign(8, VIDEOBUFFER_SIZE + MP_INPUT_BUFFER_PADDING_SIZE); |
27282
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27269
diff
changeset
|
294 if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, MP_INPUT_BUFFER_PADDING_SIZE); |
17226
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
295 else { |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
296 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail); |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
297 return 0; |
255b14c0bc36
malloc padding to avoid access beyond allocated memory
henry
parents:
17012
diff
changeset
|
298 } |
2567 | 299 } |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
300 |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
301 if(!read_video_packet(d_video)){ |
2567 | 302 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdr); |
303 return 0; | |
304 } | |
305 if(mp_header_process_sequence_header (&picture, &videobuffer[4])) { | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
306 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdr); |
17277
c568f01ef9f9
search next sequence_header untile a valid one is found
nicodvb
parents:
17226
diff
changeset
|
307 goto mpeg_header_parser; |
2567 | 308 } |
309 if(sync_video_packet(d_video)==0x1B5){ // next packet is seq. ext. | |
310 int pos=videobuf_len; | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
311 if(!read_video_packet(d_video)){ |
2567 | 312 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_CannotReadMpegSequHdrEx); |
313 return 0; | |
314 } | |
315 if(mp_header_process_extension (&picture, &videobuffer[pos+4])) { | |
316 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_BadMpegSequHdrEx); | |
317 return 0; | |
318 } | |
319 } | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
320 |
2567 | 321 // display info: |
322 sh_video->format=picture.mpeg1?0x10000001:0x10000002; // mpeg video | |
30641
b14b32c20935
Fix fps output with -identify when frame rate extension is used for MPEG-2
reimar
parents:
30639
diff
changeset
|
323 sh_video->fps=picture.fps * picture.frame_rate_extension_n / picture.frame_rate_extension_d; |
2567 | 324 if(!sh_video->fps){ |
325 sh_video->frametime=0; | |
326 } else { | |
30924
798e4a2b2571
100l, fix frametime calculation for MPEG-2 files with frame rate extension.
reimar
parents:
30862
diff
changeset
|
327 sh_video->frametime=1.0/sh_video->fps; |
2567 | 328 } |
329 sh_video->disp_w=picture.display_picture_width; | |
330 sh_video->disp_h=picture.display_picture_height; | |
331 // bitrate: | |
332 if(picture.bitrate!=0x3FFFF) // unspecified/VBR ? | |
9606
0197c1e933fe
This patch corrects the calculation of the MPEG bitrate from the
arpi
parents:
9457
diff
changeset
|
333 sh_video->i_bps=picture.bitrate * 400 / 8; |
2567 | 334 // info: |
335 mp_dbg(MSGT_DECVIDEO,MSGL_DBG2,"mpeg bitrate: %d (%X)\n",picture.bitrate,picture.bitrate); | |
10709 | 336 mp_msg(MSGT_DECVIDEO,MSGL_INFO,"VIDEO: %s %dx%d (aspect %d) %5.3f fps %5.1f kbps (%4.1f kbyte/s)\n", |
2567 | 337 picture.mpeg1?"MPEG1":"MPEG2", |
338 sh_video->disp_w,sh_video->disp_h, | |
339 picture.aspect_ratio_information, | |
340 sh_video->fps, | |
9606
0197c1e933fe
This patch corrects the calculation of the MPEG bitrate from the
arpi
parents:
9457
diff
changeset
|
341 sh_video->i_bps * 8 / 1000.0, |
0197c1e933fe
This patch corrects the calculation of the MPEG bitrate from the
arpi
parents:
9457
diff
changeset
|
342 sh_video->i_bps / 1000.0 ); |
2567 | 343 break; |
344 } | |
21949
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
345 case VIDEO_VC1: { |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
346 // Find sequence_header: |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
347 videobuf_len=0; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
348 videobuf_code_len=0; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
349 mp_msg(MSGT_DECVIDEO,MSGL_INFO,"Searching for VC1 sequence header... "); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
350 while(1){ |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
351 int i=sync_video_packet(d_video); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
352 if(i==0x10F) break; // found it! |
21951
bd3c871c93d0
in vc1 probing code, all packets before the first sequence header must be skipped, not read
nicodvb
parents:
21950
diff
changeset
|
353 if(!i || !skip_video_packet(d_video)){ |
21949
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
354 if( mp_msg_test(MSGT_DECVIDEO,MSGL_V) ) mp_msg(MSGT_DECVIDEO,MSGL_V,"NONE :(\n"); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
355 mp_msg(MSGT_DECVIDEO,MSGL_ERR, "Couldn't find VC-1 sequence header\n"); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
356 return 0; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
357 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
358 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
359 mp_msg(MSGT_DECVIDEO,MSGL_INFO,"found\n"); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
360 if(!videobuffer) { |
32763
ce9c41d97bfd
Do not pointlessly cast the return value of memalign().
diego
parents:
32568
diff
changeset
|
361 videobuffer = memalign(8, VIDEOBUFFER_SIZE + MP_INPUT_BUFFER_PADDING_SIZE); |
27282
16beae919ff1
Avoid including avcodec.h in demuxer.h (and thus many other files) just to get
reimar
parents:
27269
diff
changeset
|
362 if (videobuffer) memset(videobuffer+VIDEOBUFFER_SIZE, 0, MP_INPUT_BUFFER_PADDING_SIZE); |
21949
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
363 else { |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
364 mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_ShMemAllocFail); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
365 return 0; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
366 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
367 } |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
29238
diff
changeset
|
368 if(!read_video_packet(d_video)){ |
21949
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
369 mp_msg(MSGT_DECVIDEO,MSGL_ERR, "Couldn't read VC-1 sequence header!\n"); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
370 return 0; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
371 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
372 |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
373 while(1) { |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
374 int i=sync_video_packet(d_video); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
375 if(i==0x10E) break; // found it! |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
376 if(!i || !skip_video_packet(d_video)){ |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
377 mp_msg(MSGT_DECVIDEO,MSGL_V,"Couldn't find VC-1 entry point sync-code:(\n"); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
378 return 0; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
379 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
380 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
381 if(!read_video_packet(d_video)){ |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
382 mp_msg(MSGT_DECVIDEO,MSGL_V,"Couldn't read VC-1 entry point sync-code:(\n"); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
383 return 0; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
384 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
385 |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
386 if(mp_vc1_decode_sequence_header(&picture, &videobuffer[4], videobuf_len-4)) { |
32105 | 387 sh_video->bih = calloc(1, sizeof(*sh_video->bih) + videobuf_len); |
21952
58d083ace2f2
vc1 probing code: if sh_video->bih can't be callocated exit
nicodvb
parents:
21951
diff
changeset
|
388 if(sh_video->bih == NULL) { |
32105 | 389 mp_msg(MSGT_DECVIDEO,MSGL_ERR,"Couldn't alloc %d bytes for VC-1 extradata!\n", sizeof(*sh_video->bih) + videobuf_len); |
21952
58d083ace2f2
vc1 probing code: if sh_video->bih can't be callocated exit
nicodvb
parents:
21951
diff
changeset
|
390 return 0; |
58d083ace2f2
vc1 probing code: if sh_video->bih can't be callocated exit
nicodvb
parents:
21951
diff
changeset
|
391 } |
32105 | 392 sh_video->bih->biSize= sizeof(*sh_video->bih) + videobuf_len; |
21949
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
393 memcpy(sh_video->bih + 1, videobuffer, videobuf_len); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
394 sh_video->bih->biCompression = sh_video->format; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
395 sh_video->bih->biWidth = sh_video->disp_w = picture.display_picture_width; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
396 sh_video->bih->biHeight = sh_video->disp_h = picture.display_picture_height; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
397 if(picture.fps > 0) { |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
398 sh_video->frametime=1.0/picture.fps; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
399 sh_video->fps = picture.fps; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
400 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
401 mp_msg(MSGT_DECVIDEO,MSGL_INFO,"VIDEO: VC-1 %dx%d, %5.3f fps, header len: %d\n", |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
402 sh_video->disp_w, sh_video->disp_h, sh_video->fps, videobuf_len); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
403 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
404 break; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
405 } |
2567 | 406 } // switch(file_format) |
407 | |
408 return 1; | |
409 } | |
410 | |
32568 | 411 static void process_userdata(const unsigned char* buf,int len){ |
4074 | 412 int i; |
6791 | 413 /* if the user data starts with "CC", assume it is a CC info packet */ |
414 if(len>2 && buf[0]=='C' && buf[1]=='C'){ | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
415 // mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"video.c: process_userdata() detected Closed Captions!\n"); |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
416 subcc_process_data(buf+2,len-2); |
6784
b38e38b6f88f
DVD Closed Captioning support, patch by Matteo Giani <matgiani@ctonet.it>, small changes by me.
atmos4
parents:
6571
diff
changeset
|
417 } |
10263 | 418 if( len > 2 && buf[ 0 ] == 'T' && buf[ 1 ] == 'Y' ) |
419 { | |
420 ty_processuserdata( buf + 2, len - 2 ); | |
421 return; | |
422 } | |
7208 | 423 if(verbose<2) return; |
24839
69f5bb02b659
in process_userdata() move debugging messages from stdout to stderr
nicodvb
parents:
24838
diff
changeset
|
424 fprintf(stderr, "user_data: len=%3d %02X %02X %02X %02X '", |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
425 len, buf[0], buf[1], buf[2], buf[3]); |
4074 | 426 for(i=0;i<len;i++) |
24839
69f5bb02b659
in process_userdata() move debugging messages from stdout to stderr
nicodvb
parents:
24838
diff
changeset
|
427 // if(buf[i]>=32 && buf[i]<127) fputc(buf[i], stderr); |
69f5bb02b659
in process_userdata() move debugging messages from stdout to stderr
nicodvb
parents:
24838
diff
changeset
|
428 if(buf[i]&0x60) fputc(buf[i]&0x7F, stderr); |
69f5bb02b659
in process_userdata() move debugging messages from stdout to stderr
nicodvb
parents:
24838
diff
changeset
|
429 fprintf(stderr, "'\n"); |
4074 | 430 } |
431 | |
2567 | 432 int video_read_frame(sh_video_t* sh_video,float* frame_time_ptr,unsigned char** start,int force_fps){ |
433 demux_stream_t *d_video=sh_video->ds; | |
434 demuxer_t *demuxer=d_video->demuxer; | |
435 float frame_time=1; | |
436 float pts1=d_video->pts; | |
8965 | 437 float pts=0; |
30639
102ae81b5dc8
Parse and use the information from the frame rate extension header for MPEG-2.
reimar
parents:
30633
diff
changeset
|
438 float fps; |
8965 | 439 int picture_coding_type=0; |
2567 | 440 int in_size=0; |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
441 video_codec_t video_codec = find_video_codec(sh_video); |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
442 |
2567 | 443 *start=NULL; |
444 | |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
445 if(video_codec == VIDEO_MPEG12){ |
2567 | 446 int in_frame=0; |
447 //float newfps; | |
448 //videobuf_len=0; | |
449 while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){ | |
450 int i=sync_video_packet(d_video); | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
451 //void* buffer=&videobuffer[videobuf_len+4]; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
452 int start=videobuf_len+4; |
2567 | 453 if(in_frame){ |
454 if(i<0x101 || i>=0x1B0){ // not slice code -> end of frame | |
455 if(!i) return -1; // EOF | |
456 break; | |
457 } | |
458 } else { | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
459 if(i==0x100){ |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
460 pts=d_video->pts; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
461 d_video->pts=0; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
462 } |
2567 | 463 if(i>=0x101 && i<0x1B0) in_frame=1; // picture startcode |
464 else if(!i) return -1; // EOF | |
465 } | |
466 if(!read_video_packet(d_video)) return -1; // EOF | |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
467 // process headers: |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
468 switch(i){ |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
469 case 0x1B3: mp_header_process_sequence_header (&picture, &videobuffer[start]);break; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
470 case 0x1B5: mp_header_process_extension (&picture, &videobuffer[start]);break; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
471 case 0x1B2: process_userdata (&videobuffer[start], videobuf_len-start);break; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
472 case 0x100: picture_coding_type=(videobuffer[start+1] >> 3) & 7;break; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
473 } |
2567 | 474 } |
30639
102ae81b5dc8
Parse and use the information from the frame rate extension header for MPEG-2.
reimar
parents:
30633
diff
changeset
|
475 fps = picture.fps * picture.frame_rate_extension_n / picture.frame_rate_extension_d; |
2567 | 476 |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
477 *start=videobuffer; in_size=videobuf_len; |
2567 | 478 |
479 // get mpeg fps: | |
30639
102ae81b5dc8
Parse and use the information from the frame rate extension header for MPEG-2.
reimar
parents:
30633
diff
changeset
|
480 if(sh_video->fps!=fps) if(!force_fps && !telecine){ |
102ae81b5dc8
Parse and use the information from the frame rate extension header for MPEG-2.
reimar
parents:
30633
diff
changeset
|
481 mp_msg(MSGT_CPLAYER,MSGL_WARN,"Warning! FPS changed %5.3f -> %5.3f (%f) [%d] \n",sh_video->fps,fps,sh_video->fps-fps,picture.frame_rate_code); |
102ae81b5dc8
Parse and use the information from the frame rate extension header for MPEG-2.
reimar
parents:
30633
diff
changeset
|
482 sh_video->fps=fps; |
102ae81b5dc8
Parse and use the information from the frame rate extension header for MPEG-2.
reimar
parents:
30633
diff
changeset
|
483 sh_video->frametime=1.0/fps; |
2567 | 484 } |
485 | |
486 // fix mpeg2 frametime: | |
487 frame_time=(picture.display_time)*0.01f; | |
488 picture.display_time=100; | |
489 videobuf_len=0; | |
490 | |
8967 | 491 telecine_cnt*=0.9; // drift out error |
492 telecine_cnt+=frame_time-5.0/4.0; | |
9221 | 493 mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"\r telecine = %3.1f %5.3f \n",frame_time,telecine_cnt); |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
494 |
8967 | 495 if(telecine){ |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
496 frame_time=1; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
497 if(telecine_cnt<-1.5 || telecine_cnt>1.5){ |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
498 mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_LeaveTelecineMode); |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
499 telecine=0; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
500 } |
8967 | 501 } else |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
502 if(telecine_cnt>-0.5 && telecine_cnt<0.5 && !force_fps){ |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
503 sh_video->fps=sh_video->fps*4/5; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
504 sh_video->frametime=sh_video->frametime*5/4; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
505 mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_EnterTelecineMode); |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
506 telecine=1; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
507 } |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
508 } else if(video_codec == VIDEO_MPEG4){ |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
509 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
|
510 int i=sync_video_packet(d_video); |
14923
658fc109eefc
added support for other codecs (mpeg4/h264/aac) in mpeg-ps parsing the PSM
nicodvb
parents:
14798
diff
changeset
|
511 if(!i) return -1; |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
512 if(!read_video_packet(d_video)) return -1; // EOF |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
513 if(i==0x1B6) break; |
9069
0d2b25a821c9
raw mpeg4-es support (you need to set -fps manually!)
arpi
parents:
8967
diff
changeset
|
514 } |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
515 *start=videobuffer; in_size=videobuf_len; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
516 videobuf_len=0; |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
517 } else if(video_codec == VIDEO_H264){ |
16505
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
518 int in_picture = 0; |
9824 | 519 while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE){ |
520 int i=sync_video_packet(d_video); | |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
521 int pos = videobuf_len+4; |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
522 if(!i) return -1; |
9824 | 523 if(!read_video_packet(d_video)) return -1; // EOF |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
524 if((i&~0x60) == 0x107 && i != 0x107) { |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
525 h264_parse_sps(&picture, &(videobuffer[pos]), videobuf_len - pos); |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
526 if(picture.fps > 0) { |
16184
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
527 sh_video->fps=picture.fps; |
04dd5945fab8
100l to whoever wrote this crap using 1/10000 units. it caused framerates to get trashed from 30000/1001 to 2997/100, etc.!
rfelker
parents:
14923
diff
changeset
|
528 sh_video->frametime=1.0/picture.fps; |
14798
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
529 } |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
530 i=sync_video_packet(d_video); |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
531 if(!i) return -1; |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
532 if(!read_video_packet(d_video)) return -1; // EOF |
0bd50330e688
framerate autodetection for H264 in raw/ts streams
nicodvb
parents:
14477
diff
changeset
|
533 } |
16505
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
534 |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
535 // here starts the access unit end detection code |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
536 // see the mail on MPlayer-dev-eng for details: |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
537 // Date: Sat, 17 Sep 2005 11:24:06 +0200 |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
538 // Subject: Re: [MPlayer-dev-eng] [RFC] h264 ES parser problems |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
539 // Message-ID: <20050917092406.GA7699@rz.uni-karlsruhe.de> |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
540 if((i&~0x60) == 0x101 || (i&~0x60) == 0x102 || (i&~0x60) == 0x105) |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
541 // found VCL NAL with slice header i.e. start of current primary coded |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
542 // picture, so start scanning for the end now |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
543 in_picture = 1; |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
544 if (in_picture) { |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
545 i = sync_video_packet(d_video) & ~0x60; // code of next packet |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
546 if(i == 0x106 || i == 0x109) break; // SEI or access unit delim. |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
547 if(i == 0x101 || i == 0x102 || i == 0x105) { |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
548 // assuming arbitrary slice ordering is not allowed, the |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
549 // first_mb_in_slice (golomb encoded) value should be 0 then |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
550 // for the first VCL NAL in a picture |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
551 if (demux_peekc(d_video) & 0x80) |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
552 break; |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
553 } |
cb6599e433d7
Fix H264 packetizer. Might not work with arbitrary slice order.
reimar
parents:
16314
diff
changeset
|
554 } |
9824 | 555 } |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
556 *start=videobuffer; in_size=videobuf_len; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
557 videobuf_len=0; |
24832
e0ae2a33857a
cosmetics: moved to function find_video_codec() and reused in video_read_*() the code that identifies the various mpeg* formats
nicodvb
parents:
23752
diff
changeset
|
558 } else if(video_codec == VIDEO_VC1) { |
21949
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
559 while(videobuf_len<VIDEOBUFFER_SIZE-MAX_VIDEO_PACKET_SIZE) { |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
560 int i=sync_video_packet(d_video); |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
561 if(!i) return -1; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
562 if(!read_video_packet(d_video)) return -1; // EOF |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
563 if(i==0x10D) break; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
564 } |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
565 *start=videobuffer; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
566 in_size=videobuf_len; |
202327a68635
decode vc1 sequence header and frame it in video_read_frame();
nicodvb
parents:
21809
diff
changeset
|
567 videobuf_len=0; |
2567 | 568 } else { |
569 // frame-based file formats: (AVI,ASF,MOV) | |
570 in_size=ds_get_packet(d_video,start); | |
571 if(in_size<0) return -1; // EOF | |
572 } | |
573 | |
574 | |
575 //------------------------ frame decoded. -------------------- | |
576 | |
577 // Increase video timers: | |
578 sh_video->num_frames+=frame_time; | |
579 ++sh_video->num_frames_decoded; | |
580 | |
581 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
|
582 |
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
583 // 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
|
584 if(!force_fps) switch(demuxer->file_format){ |
9693
1d598bf65571
10l, found by Jan Kritzner <kritzner@informatik.rwth-aachen.de>
alex
parents:
9610
diff
changeset
|
585 case DEMUXER_TYPE_GIF: |
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
|
586 case DEMUXER_TYPE_MATROSKA: |
28018
4ac70bd6acac
MNG demuxer by Stefan Schuermans, stefan blinkenarea org
diego
parents:
27457
diff
changeset
|
587 case DEMUXER_TYPE_MNG: |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
588 if(d_video->pts>0 && pts1>0 && d_video->pts>pts1) |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
589 frame_time=d_video->pts-pts1; |
6423 | 590 break; |
5573
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
591 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
|
592 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
|
593 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
|
594 case DEMUXER_TYPE_VIVO: |
19802
f1655de446c4
Support for variable fps OGM files, blessed by Moritz.
diego
parents:
19695
diff
changeset
|
595 case DEMUXER_TYPE_OGG: |
5573
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
596 case DEMUXER_TYPE_ASF: { |
21809
2c473e083c70
Make ds_get_next_pts return MP_NOPTS_VALUE instead of -1 on error,
reimar
parents:
21236
diff
changeset
|
597 double next_pts = ds_get_next_pts(d_video); |
2c473e083c70
Make ds_get_next_pts return MP_NOPTS_VALUE instead of -1 on error,
reimar
parents:
21236
diff
changeset
|
598 double d= (next_pts != MP_NOPTS_VALUE) ? 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
|
599 if(d>=0){ |
6423 | 600 if(d>0){ |
19082
a2f20562aac3
Remove support for obsolete and non-free divx4/odivx libraries.
diego
parents:
18942
diff
changeset
|
601 if((int)sh_video->fps==1000) |
6423 | 602 mp_msg(MSGT_CPLAYER,MSGL_V,"\navg. framerate: %d fps \n",(int)(1.0f/d)); |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
603 sh_video->frametime=d; // 1ms |
6423 | 604 sh_video->fps=1.0f/d; |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
605 } |
5930
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5898
diff
changeset
|
606 frame_time = d; |
68cac7ecaf05
Fix frame_time for variable fps movies as it was the last frame duration.
albeu
parents:
5898
diff
changeset
|
607 } else { |
6423 | 608 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); |
609 // frame_time = 1/25.0; | |
2567 | 610 } |
5573
b8a8ab95c73d
generalized the cut'n'pasted variable fps code, #ifdef-ed TV until v4l is updated
arpi
parents:
5572
diff
changeset
|
611 } |
9693
1d598bf65571
10l, found by Jan Kritzner <kritzner@informatik.rwth-aachen.de>
alex
parents:
9610
diff
changeset
|
612 break; |
12170 | 613 case DEMUXER_TYPE_LAVF: |
27457
16a2329e8776
handle the lavfpref demuxer in the same way as the lavf one
aurel
parents:
27397
diff
changeset
|
614 case DEMUXER_TYPE_LAVF_PREFERRED: |
12170 | 615 if((int)sh_video->fps==1000 || (int)sh_video->fps<=1){ |
21809
2c473e083c70
Make ds_get_next_pts return MP_NOPTS_VALUE instead of -1 on error,
reimar
parents:
21236
diff
changeset
|
616 double next_pts = ds_get_next_pts(d_video); |
2c473e083c70
Make ds_get_next_pts return MP_NOPTS_VALUE instead of -1 on error,
reimar
parents:
21236
diff
changeset
|
617 double d= (next_pts != MP_NOPTS_VALUE) ? next_pts - d_video->pts : d_video->pts-pts1; |
12170 | 618 if(d>=0){ |
619 frame_time = d; | |
24837 | 620 } |
12170 | 621 } |
622 break; | |
18942
cf05a9897d1b
Revert r18878, always sync rm files using only pts (ignore framerate)
rtogni
parents:
18873
diff
changeset
|
623 case DEMUXER_TYPE_REAL: |
cf05a9897d1b
Revert r18878, always sync rm files using only pts (ignore framerate)
rtogni
parents:
18873
diff
changeset
|
624 { |
19695 | 625 double next_pts = ds_get_next_pts(d_video); |
21809
2c473e083c70
Make ds_get_next_pts return MP_NOPTS_VALUE instead of -1 on error,
reimar
parents:
21236
diff
changeset
|
626 double d = (next_pts != MP_NOPTS_VALUE) ? next_pts - d_video->pts : d_video->pts - pts1; |
18942
cf05a9897d1b
Revert r18878, always sync rm files using only pts (ignore framerate)
rtogni
parents:
18873
diff
changeset
|
627 |
19655
bddd0b58efb6
Workaround for live Real streams starting with nonzero pts
rtogni
parents:
19082
diff
changeset
|
628 frame_time = (d >= 0 && pts1 > 0) ? d : 0.001; |
18942
cf05a9897d1b
Revert r18878, always sync rm files using only pts (ignore framerate)
rtogni
parents:
18873
diff
changeset
|
629 } |
cf05a9897d1b
Revert r18878, always sync rm files using only pts (ignore framerate)
rtogni
parents:
18873
diff
changeset
|
630 break; |
2567 | 631 } |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
632 |
24836
4e90fdb819b0
replaced giant if() with if(pre-calculated variable) (there was even a bug: PS doesn't necessarily contain mpeg12)
nicodvb
parents:
24834
diff
changeset
|
633 if(video_codec == VIDEO_MPEG12){ |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
634 sh_video->pts+=frame_time; |
24912
384aa7179c9c
in video_read_frame() set the keyframe flag in demuxer->video when dealing with
nicodvb
parents:
24850
diff
changeset
|
635 if(picture_coding_type==1) |
384aa7179c9c
in video_read_frame() set the keyframe flag in demuxer->video when dealing with
nicodvb
parents:
24850
diff
changeset
|
636 d_video->flags |= 1; |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
637 if(picture_coding_type<=2 && sh_video->i_pts){ |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
638 sh_video->pts=sh_video->i_pts; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
639 sh_video->i_pts=pts; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
640 } else { |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
641 if(pts){ |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
642 if(picture_coding_type<=2) sh_video->i_pts=pts; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
643 else sh_video->pts=pts; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
644 } |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
645 } |
8965 | 646 } else |
24834
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
647 sh_video->pts=d_video->pts; |
a8ef08f502c0
cosmetics: removed tabs/empty lines/trailing spaces and done a partial reformatting where desperately needed
nicodvb
parents:
24832
diff
changeset
|
648 |
2567 | 649 if(frame_time_ptr) *frame_time_ptr=frame_time; |
650 return in_size; | |
651 } |