Mercurial > libavformat.hg
annotate dvenc.c @ 5953:c3ebc8d7af38 libavformat
Remove useless assert(), since this can (in theora) be used for any Xiph
codec, so there's no reason to (invalidly) limit it to only Theora.
Also fixes issue 1880 (compilation error on -DDEBUG).
author | rbultje |
---|---|
date | Thu, 15 Apr 2010 13:30:12 +0000 |
parents | 536e5527c1e0 |
children | 9fef9c7acf03 |
rev | line source |
---|---|
885 | 1 /* |
2 * General DV muxer/demuxer | |
933 | 3 * Copyright (c) 2003 Roman Shaposhnik |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
4 * |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
5 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
6 * of DV technical info. |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
7 * |
0 | 8 * Raw DV format |
4251
77e0c7511d41
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
4206
diff
changeset
|
9 * Copyright (c) 2002 Fabrice Bellard |
0 | 10 * |
995 | 11 * 50 Mbps (DVCPRO50) support |
12 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com> | |
13 * | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1322
diff
changeset
|
14 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1322
diff
changeset
|
15 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1322
diff
changeset
|
16 * FFmpeg is free software; you can redistribute it and/or |
0 | 17 * modify it under the terms of the GNU Lesser General Public |
18 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1322
diff
changeset
|
19 * version 2.1 of the License, or (at your option) any later version. |
0 | 20 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1322
diff
changeset
|
21 * FFmpeg is distributed in the hope that it will be useful, |
0 | 22 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
24 * Lesser General Public License for more details. | |
25 * | |
26 * You should have received a copy of the GNU Lesser General Public | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1322
diff
changeset
|
27 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
887
diff
changeset
|
28 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 29 */ |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
30 #include <time.h> |
1656
184229324f14
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
1466
diff
changeset
|
31 #include <stdarg.h> |
0 | 32 #include "avformat.h" |
3286 | 33 #include "libavcodec/dvdata.h" |
296
252946de6d3f
* DV demuxer is now capable of decoding auxilary audio stream. So,
romansh
parents:
288
diff
changeset
|
34 #include "dv.h" |
3286 | 35 #include "libavutil/fifo.h" |
0 | 36 |
296
252946de6d3f
* DV demuxer is now capable of decoding auxilary audio stream. So,
romansh
parents:
288
diff
changeset
|
37 struct DVMuxContext { |
4007 | 38 const DVprofile* sys; /* current DV profile, e.g.: 525/60, 625/50 */ |
39 int n_ast; /* number of stereo audio streams (up to 2) */ | |
40 AVStream *ast[2]; /* stereo audio streams */ | |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
41 AVFifoBuffer *audio_data[2]; /* FIFO for storing excessive amounts of PCM */ |
4007 | 42 int frames; /* current frame number */ |
43 time_t start_time; /* recording start time */ | |
4008 | 44 int has_audio; /* frame under contruction has audio */ |
45 int has_video; /* frame under contruction has video */ | |
46 uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under contruction */ | |
296
252946de6d3f
* DV demuxer is now capable of decoding auxilary audio stream. So,
romansh
parents:
288
diff
changeset
|
47 }; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
48 |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
49 static const int dv_aaux_packs_dist[12][9] = { |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
50 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
51 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
52 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
53 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
54 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
55 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
56 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
57 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
58 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
59 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
60 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
61 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff }, |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
62 }; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
63 |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
64 static int dv_audio_frame_size(const DVprofile* sys, int frame) |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
65 { |
4008 | 66 return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist) / |
887 | 67 sizeof(sys->audio_samples_dist[0]))]; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
68 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
69 |
1656
184229324f14
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
1466
diff
changeset
|
70 static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* buf, ...) |
0 | 71 { |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
72 struct tm tc; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
73 time_t ct; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
74 int ltc_frame; |
1656
184229324f14
* Fixing a bug with incorrect bits set in AAUX source pack
romansh
parents:
1466
diff
changeset
|
75 va_list ap; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
76 |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
77 buf[0] = (uint8_t)pack_id; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
78 switch (pack_id) { |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
79 case dv_timecode: |
4008 | 80 ct = (time_t)av_rescale_rnd(c->frames, c->sys->time_base.num, |
81 c->sys->time_base.den, AV_ROUND_DOWN); | |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
82 brktimegm(ct, &tc); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
83 /* |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
84 * LTC drop-frame frame counter drops two frames (0 and 1) every |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
85 * minute, unless it is exactly divisible by 10 |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
86 */ |
4008 | 87 ltc_frame = (c->frames + 2 * ct / 60 - 2 * ct / 600) % c->sys->ltc_divisor; |
4007 | 88 buf[1] = (0 << 7) | /* color frame: 0 - unsync; 1 - sync mode */ |
89 (1 << 6) | /* drop frame timecode: 0 - nondrop; 1 - drop */ | |
90 ((ltc_frame / 10) << 4) | /* tens of frames */ | |
91 (ltc_frame % 10); /* units of frames */ | |
92 buf[2] = (1 << 7) | /* biphase mark polarity correction: 0 - even; 1 - odd */ | |
93 ((tc.tm_sec / 10) << 4) | /* tens of seconds */ | |
94 (tc.tm_sec % 10); /* units of seconds */ | |
95 buf[3] = (1 << 7) | /* binary group flag BGF0 */ | |
96 ((tc.tm_min / 10) << 4) | /* tens of minutes */ | |
97 (tc.tm_min % 10); /* units of minutes */ | |
98 buf[4] = (1 << 7) | /* binary group flag BGF2 */ | |
99 (1 << 6) | /* binary group flag BGF1 */ | |
100 ((tc.tm_hour / 10) << 4) | /* tens of hours */ | |
101 (tc.tm_hour % 10); /* units of hours */ | |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
102 break; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
103 case dv_audio_source: /* AAUX source pack */ |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
104 va_start(ap, buf); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
105 buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
106 (1 << 6) | /* reserved -- always 1 */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
107 (dv_audio_frame_size(c->sys, c->frames) - |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
108 c->sys->audio_min_samples[0]); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
109 /* # of samples */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
110 buf[2] = (0 << 7) | /* multi-stereo */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
111 (0 << 5) | /* #of audio channels per block: 0 -- 1 channel */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
112 (0 << 4) | /* pair bit: 0 -- one pair of channels */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
113 !!va_arg(ap, int); /* audio mode */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
114 buf[3] = (1 << 7) | /* res */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
115 (1 << 6) | /* multi-language flag */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
116 (c->sys->dsf << 5) | /* system: 60fields/50fields */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
117 (c->sys->n_difchan & 2); /* definition: 0 -- 25Mbps, 2 -- 50Mbps */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
118 buf[4] = (1 << 7) | /* emphasis: 1 -- off */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
119 (0 << 6) | /* emphasis time constant: 0 -- reserved */ |
3968 | 120 (0 << 3) | /* frequency: 0 -- 48kHz, 1 -- 44,1kHz, 2 -- 32kHz */ |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
121 0; /* quantization: 0 -- 16bit linear, 1 -- 12bit nonlinear */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
122 va_end(ap); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
123 break; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
124 case dv_audio_control: |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
125 buf[1] = (0 << 6) | /* copy protection: 0 -- unrestricted */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
126 (1 << 4) | /* input source: 1 -- digital input */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
127 (3 << 2) | /* compression: 3 -- no information */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
128 0; /* misc. info/SMPTE emphasis off */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
129 buf[2] = (1 << 7) | /* recording start point: 1 -- no */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
130 (1 << 6) | /* recording end point: 1 -- no */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
131 (1 << 3) | /* recording mode: 1 -- original */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
132 7; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
133 buf[3] = (1 << 7) | /* direction: 1 -- forward */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
134 (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0x20 : /* speed */ |
4008 | 135 c->sys->ltc_divisor * 4); |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
136 buf[4] = (1 << 7) | /* reserved -- always 1 */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
137 0x7f; /* genre category */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
138 break; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
139 case dv_audio_recdate: |
848 | 140 case dv_video_recdate: /* VAUX recording date */ |
3992
36f92f77c85e
replacing frame_rate and frame_rate_base with an AVRational time_base
romansh
parents:
3968
diff
changeset
|
141 ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num, |
4008 | 142 c->sys->time_base.den, AV_ROUND_DOWN); |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
143 brktimegm(ct, &tc); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
144 buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
145 /* 0xff is very likely to be "unknown" */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
146 buf[2] = (3 << 6) | /* reserved -- always 1 */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
147 ((tc.tm_mday / 10) << 4) | /* Tens of day */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
148 (tc.tm_mday % 10); /* Units of day */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
149 buf[3] = /* we set high 4 bits to 0, shouldn't we set them to week? */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
150 ((tc.tm_mon / 10) << 4) | /* Tens of month */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
151 (tc.tm_mon % 10); /* Units of month */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
152 buf[4] = (((tc.tm_year % 100) / 10) << 4) | /* Tens of year */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
153 (tc.tm_year % 10); /* Units of year */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
154 break; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
155 case dv_audio_rectime: /* AAUX recording time */ |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
156 case dv_video_rectime: /* VAUX recording time */ |
3992
36f92f77c85e
replacing frame_rate and frame_rate_base with an AVRational time_base
romansh
parents:
3968
diff
changeset
|
157 ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num, |
36f92f77c85e
replacing frame_rate and frame_rate_base with an AVRational time_base
romansh
parents:
3968
diff
changeset
|
158 c->sys->time_base.den, AV_ROUND_DOWN); |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
159 brktimegm(ct, &tc); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
160 buf[1] = (3 << 6) | /* reserved -- always 1 */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
161 0x3f; /* tens of frame, units of frame: 0x3f - "unknown" ? */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
162 buf[2] = (1 << 7) | /* reserved -- always 1 */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
163 ((tc.tm_sec / 10) << 4) | /* Tens of seconds */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
164 (tc.tm_sec % 10); /* Units of seconds */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
165 buf[3] = (1 << 7) | /* reserved -- always 1 */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
166 ((tc.tm_min / 10) << 4) | /* Tens of minutes */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
167 (tc.tm_min % 10); /* Units of minutes */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
168 buf[4] = (3 << 6) | /* reserved -- always 1 */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
169 ((tc.tm_hour / 10) << 4) | /* Tens of hours */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
170 (tc.tm_hour % 10); /* Units of hours */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
171 break; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
172 default: |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
173 buf[1] = buf[2] = buf[3] = buf[4] = 0xff; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
174 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
175 return 5; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
176 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
177 |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
178 static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr) |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
179 { |
504 | 180 int i, j, d, of, size; |
181 size = 4 * dv_audio_frame_size(c->sys, c->frames); | |
995 | 182 frame_ptr += channel * c->sys->difseg_size * 150 * 80; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
183 for (i = 0; i < c->sys->difseg_size; i++) { |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
184 frame_ptr += 6 * 80; /* skip DIF segment header */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
185 for (j = 0; j < 9; j++) { |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
186 dv_write_pack(dv_aaux_packs_dist[i][j], c, &frame_ptr[3], i >= c->sys->difseg_size/2); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
187 for (d = 8; d < 80; d+=2) { |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
188 of = c->sys->audio_shuffle[i][j] + (d - 8)/2 * c->sys->audio_stride; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
189 if (of*2 >= size) |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
190 continue; |
885 | 191 |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
192 frame_ptr[d] = av_fifo_peek(c->audio_data[channel], of*2+1); // FIXME: maybe we have to admit |
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
193 frame_ptr[d+1] = av_fifo_peek(c->audio_data[channel], of*2); // that DV is a big-endian PCM |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
194 } |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
195 frame_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
196 } |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
197 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
198 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
199 |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
200 static void dv_inject_metadata(DVMuxContext *c, uint8_t* frame) |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
201 { |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
202 int j, k; |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
203 uint8_t* buf; |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
204 |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
205 for (buf = frame; buf < frame + c->sys->frame_size; buf += 150 * 80) { |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
206 /* DV subcode: 2nd and 3d DIFs */ |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
207 for (j = 80; j < 80 * 3; j += 80) { |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
208 for (k = 6; k < 6 * 8; k += 8) |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
209 dv_write_pack(dv_timecode, c, &buf[j+k]); |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
210 |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
211 if (((long)(buf-frame)/(c->sys->frame_size/(c->sys->difseg_size*c->sys->n_difchan))%c->sys->difseg_size) > 5) { /* FIXME: is this really needed ? */ |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
212 dv_write_pack(dv_video_recdate, c, &buf[j+14]); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
213 dv_write_pack(dv_video_rectime, c, &buf[j+22]); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
214 dv_write_pack(dv_video_recdate, c, &buf[j+38]); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
215 dv_write_pack(dv_video_rectime, c, &buf[j+46]); |
995 | 216 } |
217 } | |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
218 |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
219 /* DV VAUX: 4th, 5th and 6th 3DIFs */ |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
220 for (j = 80*3 + 3; j < 80*6; j += 80) { |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
221 dv_write_pack(dv_video_recdate, c, &buf[j+5*2]); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
222 dv_write_pack(dv_video_rectime, c, &buf[j+5*3]); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
223 dv_write_pack(dv_video_recdate, c, &buf[j+5*11]); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
224 dv_write_pack(dv_video_rectime, c, &buf[j+5*12]); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
225 } |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
226 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
227 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
228 |
885 | 229 /* |
1317
132206560fe6
Split the DV demuxer and muxer into separate files (as suggested by Diego
takis
parents:
1289
diff
changeset
|
230 * The following 3 functions constitute our interface to the world |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
231 */ |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
232 |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
233 int dv_assemble_frame(DVMuxContext *c, AVStream* st, |
4162
d9dede8fe890
Remove inappropriate const qualifier from function argument, fixes the warning:
diego
parents:
4008
diff
changeset
|
234 uint8_t* data, int data_size, uint8_t** frame) |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
235 { |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
236 int i, reqasize; |
885 | 237 |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
238 *frame = &c->frame_buf[0]; |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
239 reqasize = 4 * dv_audio_frame_size(c->sys, c->frames); |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
240 |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
241 switch (st->codec->codec_type) { |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5288
diff
changeset
|
242 case AVMEDIA_TYPE_VIDEO: |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
243 /* FIXME: we have to have more sensible approach than this one */ |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
244 if (c->has_video) |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
245 av_log(st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames); |
885 | 246 |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
247 memcpy(*frame, data, c->sys->frame_size); |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
248 c->has_video = 1; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
249 break; |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5288
diff
changeset
|
250 case AVMEDIA_TYPE_AUDIO: |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
251 for (i = 0; i < c->n_ast && st != c->ast[i]; i++); |
885 | 252 |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
253 /* FIXME: we have to have more sensible approach than this one */ |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
254 if (av_fifo_size(c->audio_data[i]) + data_size >= 100*AVCODEC_MAX_AUDIO_FRAME_SIZE) |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
255 av_log(st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames); |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
256 av_fifo_generic_write(c->audio_data[i], data, data_size, NULL); |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
257 |
3596
1b3a50077124
cosmetics: Fix two common typos: wont --> will not, lets --> let us.
diego
parents:
3424
diff
changeset
|
258 /* Let us see if we've got enough audio for one DV frame. */ |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
259 c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i); |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
260 |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
261 break; |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
262 default: |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
263 break; |
885 | 264 } |
265 | |
3596
1b3a50077124
cosmetics: Fix two common typos: wont --> will not, lets --> let us.
diego
parents:
3424
diff
changeset
|
266 /* Let us see if we have enough data to construct one DV frame. */ |
4008 | 267 if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) { |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
268 dv_inject_metadata(c, *frame); |
2086
0cd7cfbee2e8
Don't forget about audio remaining in buffer, in case there is enough
corey
parents:
2006
diff
changeset
|
269 c->has_audio = 0; |
4008 | 270 for (i=0; i < c->n_ast; i++) { |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
271 dv_inject_audio(c, i, *frame); |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
272 av_fifo_drain(c->audio_data[i], reqasize); |
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
273 c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i); |
887 | 274 } |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
275 |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
276 c->has_video = 0; |
2086
0cd7cfbee2e8
Don't forget about audio remaining in buffer, in case there is enough
corey
parents:
2006
diff
changeset
|
277 |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
278 c->frames++; |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
279 |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
280 return c->sys->frame_size; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
281 } |
1289
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
282 |
6db39fb15d60
* Restructuring the division of labor between DV codec and DV format
romansh
parents:
1169
diff
changeset
|
283 return 0; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
284 } |
0 | 285 |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
286 DVMuxContext* dv_init_mux(AVFormatContext* s) |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
287 { |
2006 | 288 DVMuxContext *c = s->priv_data; |
531
2af447b91329
* let DV muxer generate audioless DV streams. This might not be 100%
romansh
parents:
528
diff
changeset
|
289 AVStream *vst = NULL; |
2af447b91329
* let DV muxer generate audioless DV streams. This might not be 100%
romansh
parents:
528
diff
changeset
|
290 int i; |
2af447b91329
* let DV muxer generate audioless DV streams. This might not be 100%
romansh
parents:
528
diff
changeset
|
291 |
995 | 292 /* we support at most 1 video and 2 audio streams */ |
293 if (s->nb_streams > 3) | |
531
2af447b91329
* let DV muxer generate audioless DV streams. This might not be 100%
romansh
parents:
528
diff
changeset
|
294 return NULL; |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
295 |
4008 | 296 c->n_ast = 0; |
995 | 297 c->ast[0] = c->ast[1] = NULL; |
298 | |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
299 /* We have to sort out where audio and where video stream is */ |
531
2af447b91329
* let DV muxer generate audioless DV streams. This might not be 100%
romansh
parents:
528
diff
changeset
|
300 for (i=0; i<s->nb_streams; i++) { |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
301 switch (s->streams[i]->codec->codec_type) { |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5288
diff
changeset
|
302 case AVMEDIA_TYPE_VIDEO: |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
303 if (vst) return NULL; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
304 vst = s->streams[i]; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
305 break; |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5288
diff
changeset
|
306 case AVMEDIA_TYPE_AUDIO: |
2192
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
307 if (c->n_ast > 1) return NULL; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
308 c->ast[c->n_ast++] = s->streams[i]; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
309 break; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
310 default: |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
311 goto bail_out; |
c97fab0f9803
Cosmetics: use consistent indentation by four spaces
reimar
parents:
2191
diff
changeset
|
312 } |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
313 } |
885 | 314 |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
315 /* Some checks -- DV format is very picky about its incoming streams */ |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
764
diff
changeset
|
316 if (!vst || vst->codec->codec_id != CODEC_ID_DVVIDEO) |
531
2af447b91329
* let DV muxer generate audioless DV streams. This might not be 100%
romansh
parents:
528
diff
changeset
|
317 goto bail_out; |
995 | 318 for (i=0; i<c->n_ast; i++) { |
4008 | 319 if (c->ast[i] && (c->ast[i]->codec->codec_id != CODEC_ID_PCM_S16LE || |
995 | 320 c->ast[i]->codec->sample_rate != 48000 || |
4008 | 321 c->ast[i]->codec->channels != 2)) |
995 | 322 goto bail_out; |
323 } | |
5288
15f34b5059ed
Split parts of dvdata.h into dvdata.c, this ensures that things like
reimar
parents:
4669
diff
changeset
|
324 c->sys = ff_dv_codec_profile(vst->codec); |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
325 if (!c->sys) |
887 | 326 goto bail_out; |
885 | 327 |
4008 | 328 if ((c->n_ast > 1) && (c->sys->n_difchan < 2)) { |
995 | 329 /* only 1 stereo pair is allowed in 25Mbps mode */ |
330 goto bail_out; | |
331 } | |
332 | |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
333 /* Ok, everything seems to be in working order */ |
4008 | 334 c->frames = 0; |
335 c->has_audio = 0; | |
336 c->has_video = 0; | |
420
e440fb884442
* making it possible to specify recording date and time in a stream
romansh
parents:
417
diff
changeset
|
337 c->start_time = (time_t)s->timestamp; |
37 | 338 |
4008 | 339 for (i=0; i < c->n_ast; i++) { |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
340 if (c->ast[i] && !(c->audio_data[i]=av_fifo_alloc(100*AVCODEC_MAX_AUDIO_FRAME_SIZE))) { |
4008 | 341 while (i > 0) { |
995 | 342 i--; |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
343 av_fifo_free(c->audio_data[i]); |
995 | 344 } |
345 goto bail_out; | |
346 } | |
347 } | |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
348 |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
349 return c; |
885 | 350 |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
351 bail_out: |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
352 return NULL; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
353 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
354 |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
355 void dv_delete_mux(DVMuxContext *c) |
885 | 356 { |
995 | 357 int i; |
358 for (i=0; i < c->n_ast; i++) | |
4669
d6eb19c43e99
Allocate AVFifoBuffer through the fifo API to reduce future API/ABI issues.
michael
parents:
4251
diff
changeset
|
359 av_fifo_free(c->audio_data[i]); |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
360 } |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
361 |
4206 | 362 #if CONFIG_DV_MUXER |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
363 static int dv_write_header(AVFormatContext *s) |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
364 { |
1466 | 365 if (!dv_init_mux(s)) { |
370
845f9de2c883
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
363
diff
changeset
|
366 av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n" |
887 | 367 "Make sure that you supply exactly two streams:\n" |
3968 | 368 " video: 25fps or 29.97fps, audio: 2ch/48kHz/PCM\n" |
995 | 369 " (50Mbps allows an optional second audio stream)\n"); |
887 | 370 return -1; |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
371 } |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
372 return 0; |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
373 } |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
374 |
468 | 375 static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt) |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
376 { |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
377 uint8_t* frame; |
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
378 int fsize; |
885 | 379 |
2006 | 380 fsize = dv_assemble_frame(s->priv_data, s->streams[pkt->stream_index], |
468 | 381 pkt->data, pkt->size, &frame); |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
382 if (fsize > 0) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2192
diff
changeset
|
383 put_buffer(s->pb, frame, fsize); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2192
diff
changeset
|
384 put_flush_packet(s->pb); |
885 | 385 } |
363
efd9dfe4f504
* turns out write_packet is supposed to return 0 on success, not
romansh
parents:
296
diff
changeset
|
386 return 0; |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
387 } |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
388 |
885 | 389 /* |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
390 * We might end up with some extra A/V data without matching counterpart. |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
391 * E.g. video data without enough audio to write the complete frame. |
885 | 392 * Currently we simply drop the last frame. I don't know whether this |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
393 * is the best strategy of all |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
394 */ |
262
f174d9c00bce
* DV handling was streamlined for both muxing/demuxing and
romansh
parents:
241
diff
changeset
|
395 static int dv_write_trailer(struct AVFormatContext *s) |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
396 { |
2006 | 397 dv_delete_mux(s->priv_data); |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
398 return 0; |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
399 } |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
400 |
1169 | 401 AVOutputFormat dv_muxer = { |
0 | 402 "dv", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3392
diff
changeset
|
403 NULL_IF_CONFIG_SMALL("DV video format"), |
0 | 404 NULL, |
405 "dv", | |
203
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
406 sizeof(DVMuxContext), |
184d22d04c84
* Phase 1 for DV encoding support. Muxing/demuxing of DV streams is now
romansh
parents:
119
diff
changeset
|
407 CODEC_ID_PCM_S16LE, |
0 | 408 CODEC_ID_DVVIDEO, |
409 dv_write_header, | |
410 dv_write_packet, | |
411 dv_write_trailer, | |
412 }; | |
3871
e6aeb2733e34
Replace generic CONFIG_MUXERS preprocessor conditionals by more specific
diego
parents:
3596
diff
changeset
|
413 #endif /* CONFIG_DV_MUXER */ |