3 * Copyright (c) 2004-2007 Michael Niedermayer
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/tree.h"
24 #include "libavcodec/mpegaudiodata.h"
27 static int find_expected_header(AVCodecContext
*c
, int size
, int key_frame
, uint8_t out
[64]){
28 int sample_rate
= c
->sample_rate
;
35 if(c
->codec_id
== CODEC_ID_MPEG4
){
42 }else if(c
->codec_id
== CODEC_ID_MPEG1VIDEO
|| c
->codec_id
== CODEC_ID_MPEG2VIDEO
){
44 }else if(c
->codec_id
== CODEC_ID_H264
){
46 }else if(c
->codec_id
== CODEC_ID_MP3
|| c
->codec_id
== CODEC_ID_MP2
){
47 int lsf
, mpeg25
, sample_rate_index
, bitrate_index
, frame_size
;
48 int layer
= c
->codec_id
== CODEC_ID_MP3
? 3 : 2;
49 unsigned int header
= 0xFFF00000;
51 lsf
= sample_rate
< (24000+32000)/2;
52 mpeg25
= sample_rate
< (12000+16000)/2;
53 sample_rate
<<= lsf
+ mpeg25
;
54 if (sample_rate
< (32000 + 44100)/2) sample_rate_index
=2;
55 else if(sample_rate
< (44100 + 48000)/2) sample_rate_index
=0;
56 else sample_rate_index
=1;
58 sample_rate
= ff_mpa_freq_tab
[sample_rate_index
] >> (lsf
+ mpeg25
);
60 for(bitrate_index
=2; bitrate_index
<30; bitrate_index
++){
61 frame_size
= ff_mpa_bitrate_tab
[lsf
][layer
-1][bitrate_index
>>1];
62 frame_size
= (frame_size
* 144000) / (sample_rate
<< lsf
) + (bitrate_index
&1);
64 if(frame_size
== size
)
69 header
|= (4-layer
)<<17;
70 header
|= 1<<16; //no crc
73 return 2; //we guess there is no crc, if there is one the user clearly does not care about overhead
74 if(bitrate_index
== 30)
75 return -1; //something is wrong ...
77 header
|= (bitrate_index
>>1)<<12;
78 header
|= sample_rate_index
<<10;
79 header
|= (bitrate_index
&1)<<9;
81 return 2; //FIXME actually put the needed ones in build_elision_headers()
82 return 3; //we guess that the private bit is not set
83 //FIXME the above assumptions should be checked, if these turn out false too often something should be done
88 static int find_header_idx(AVFormatContext
*s
, AVCodecContext
*c
, int size
, int frame_type
){
89 NUTContext
*nut
= s
->priv_data
;
92 int len
= find_expected_header(c
, size
, frame_type
, out
);
94 //av_log(NULL, AV_LOG_ERROR, "expected_h len=%d size=%d codec_id=%d\n", len, size, c->codec_id);
96 for(i
=1; i
<nut
->header_count
; i
++){
97 if( len
== nut
->header_len
[i
]
98 && !memcmp(out
, nut
->header
[i
], len
)){
99 // av_log(NULL, AV_LOG_ERROR, "found %d\n", i);
103 // av_log(NULL, AV_LOG_ERROR, "nothing found\n");
107 static void build_elision_headers(AVFormatContext
*s
){
108 NUTContext
*nut
= s
->priv_data
;
111 //FIXME write a 2pass mode to find the maximal headers
112 static const uint8_t headers
[][5]={
113 {3, 0x00, 0x00, 0x01},
114 {4, 0x00, 0x00, 0x01, 0xB6},
115 {2, 0xFF, 0xFA}, //mp3+crc
116 {2, 0xFF, 0xFB}, //mp3
117 {2, 0xFF, 0xFC}, //mp2+crc
118 {2, 0xFF, 0xFD}, //mp2
121 nut
->header_count
= 7;
122 for(i
=1; i
<nut
->header_count
; i
++){
123 nut
->header_len
[i
]= headers
[i
-1][0];
124 nut
->header
[i
]= &headers
[i
-1][1];
128 static void build_frame_code(AVFormatContext
*s
){
129 NUTContext
*nut
= s
->priv_data
;
130 int key_frame
, index
, pred
, stream_id
;
133 int keyframe_0_esc
= s
->nb_streams
> 2;
137 ft
= &nut
->frame_code
[start
];
138 ft
->flags
= FLAG_CODED
;
144 /* keyframe = 0 escape */
145 FrameCode
*ft
= &nut
->frame_code
[start
];
146 ft
->flags
= FLAG_STREAM_ID
| FLAG_SIZE_MSB
| FLAG_CODED_PTS
;
151 for(stream_id
= 0; stream_id
<s
->nb_streams
; stream_id
++){
152 int start2
= start
+ (end
-start
)*stream_id
/ s
->nb_streams
;
153 int end2
= start
+ (end
-start
)*(stream_id
+1) / s
->nb_streams
;
154 AVCodecContext
*codec
= s
->streams
[stream_id
]->codec
;
155 int is_audio
= codec
->codec_type
== CODEC_TYPE_AUDIO
;
156 int intra_only
= /*codec->intra_only || */is_audio
;
159 for(key_frame
=0; key_frame
<2; key_frame
++){
160 if(intra_only
&& keyframe_0_esc
&& key_frame
==0)
164 FrameCode
*ft
= &nut
->frame_code
[start2
];
165 ft
->flags
= FLAG_KEY
*key_frame
;
166 ft
->flags
|= FLAG_SIZE_MSB
| FLAG_CODED_PTS
;
167 ft
->stream_id
= stream_id
;
170 ft
->header_idx
= find_header_idx(s
, codec
, -1, key_frame
);
175 key_frame
= intra_only
;
178 int frame_bytes
= codec
->frame_size
*(int64_t)codec
->bit_rate
/ (8*codec
->sample_rate
);
180 for(pts
=0; pts
<2; pts
++){
181 for(pred
=0; pred
<2; pred
++){
182 FrameCode
*ft
= &nut
->frame_code
[start2
];
183 ft
->flags
= FLAG_KEY
*key_frame
;
184 ft
->stream_id
= stream_id
;
185 ft
->size_mul
=frame_bytes
+ 2;
186 ft
->size_lsb
=frame_bytes
+ pred
;
188 ft
->header_idx
= find_header_idx(s
, codec
, frame_bytes
+ pred
, key_frame
);
193 FrameCode
*ft
= &nut
->frame_code
[start2
];
194 ft
->flags
= FLAG_KEY
| FLAG_SIZE_MSB
;
195 ft
->stream_id
= stream_id
;
202 if(codec
->has_b_frames
){
209 }else if(codec
->codec_id
== CODEC_ID_VORBIS
){
219 for(pred
=0; pred
<pred_count
; pred
++){
220 int start3
= start2
+ (end2
-start2
)*pred
/ pred_count
;
221 int end3
= start2
+ (end2
-start2
)*(pred
+1) / pred_count
;
223 for(index
=start3
; index
<end3
; index
++){
224 FrameCode
*ft
= &nut
->frame_code
[index
];
225 ft
->flags
= FLAG_KEY
*key_frame
;
226 ft
->flags
|= FLAG_SIZE_MSB
;
227 ft
->stream_id
= stream_id
;
228 //FIXME use single byte size and pred from last
229 ft
->size_mul
= end3
-start3
;
230 ft
->size_lsb
= index
- start3
;
231 ft
->pts_delta
= pred_table
[pred
];
233 ft
->header_idx
= find_header_idx(s
, codec
, -1, key_frame
);
237 memmove(&nut
->frame_code
['N'+1], &nut
->frame_code
['N'], sizeof(FrameCode
)*(255-'N'));
238 nut
->frame_code
[ 0].flags
=
239 nut
->frame_code
[255].flags
=
240 nut
->frame_code
['N'].flags
= FLAG_INVALID
;
244 * Gets the length in bytes which is needed to store val as v.
246 static int get_length(uint64_t val
){
255 static void put_v(ByteIOContext
*bc
, uint64_t val
){
256 int i
= get_length(val
);
259 put_byte(bc
, 128 | (val
>>(7*i
)));
261 put_byte(bc
, val
&127);
264 static void put_tt(NUTContext
*nut
, StreamContext
*nus
, ByteIOContext
*bc
, uint64_t val
){
265 val
*= nut
->time_base_count
;
266 val
+= nus
->time_base
- nut
->time_base
;
271 * Stores a string as vb.
273 static void put_str(ByteIOContext
*bc
, const char *string
){
274 int len
= strlen(string
);
277 put_buffer(bc
, string
, len
);
280 static void put_s(ByteIOContext
*bc
, int64_t val
){
281 put_v(bc
, 2*FFABS(val
) - (val
>0));
285 static inline void put_v_trace(ByteIOContext
*bc
, uint64_t v
, char *file
, char *func
, int line
){
286 av_log(NULL
, AV_LOG_DEBUG
, "put_v %5"PRId64
" / %"PRIX64
" in %s %s:%d\n", v
, v
, file
, func
, line
);
291 static inline void put_s_trace(ByteIOContext
*bc
, int64_t v
, char *file
, char *func
, int line
){
292 av_log(NULL
, AV_LOG_DEBUG
, "put_s %5"PRId64
" / %"PRIX64
" in %s %s:%d\n", v
, v
, file
, func
, line
);
296 #define put_v(bc, v) put_v_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
297 #define put_s(bc, v) put_s_trace(bc, v, __FILE__, __PRETTY_FUNCTION__, __LINE__)
300 //FIXME remove calculate_checksum
301 static void put_packet(NUTContext
*nut
, ByteIOContext
*bc
, ByteIOContext
*dyn_bc
, int calculate_checksum
, uint64_t startcode
){
302 uint8_t *dyn_buf
=NULL
;
303 int dyn_size
= url_close_dyn_buf(dyn_bc
, &dyn_buf
);
304 int forw_ptr
= dyn_size
+ 4*calculate_checksum
;
307 init_checksum(bc
, ff_crc04C11DB7_update
, 0);
308 put_be64(bc
, startcode
);
311 put_le32(bc
, get_checksum(bc
));
313 if(calculate_checksum
)
314 init_checksum(bc
, ff_crc04C11DB7_update
, 0);
315 put_buffer(bc
, dyn_buf
, dyn_size
);
316 if(calculate_checksum
)
317 put_le32(bc
, get_checksum(bc
));
322 static void write_mainheader(NUTContext
*nut
, ByteIOContext
*bc
){
323 int i
, j
, tmp_pts
, tmp_flags
, tmp_stream
, tmp_mul
, tmp_size
, tmp_fields
, tmp_head_idx
;
326 put_v(bc
, 3); /* version */
327 put_v(bc
, nut
->avf
->nb_streams
);
328 put_v(bc
, nut
->max_distance
);
329 put_v(bc
, nut
->time_base_count
);
331 for(i
=0; i
<nut
->time_base_count
; i
++){
332 put_v(bc
, nut
->time_base
[i
].num
);
333 put_v(bc
, nut
->time_base
[i
].den
);
339 tmp_match
= 1-(1LL<<62);
345 if(tmp_pts
!= nut
->frame_code
[i
].pts_delta
) tmp_fields
=1;
346 if(tmp_mul
!= nut
->frame_code
[i
].size_mul
) tmp_fields
=2;
347 if(tmp_stream
!= nut
->frame_code
[i
].stream_id
) tmp_fields
=3;
348 if(tmp_size
!= nut
->frame_code
[i
].size_lsb
) tmp_fields
=4;
349 // if(tmp_res != nut->frame_code[i].res ) tmp_fields=5;
350 if(tmp_head_idx
!=nut
->frame_code
[i
].header_idx
)tmp_fields
=8;
352 tmp_pts
= nut
->frame_code
[i
].pts_delta
;
353 tmp_flags
= nut
->frame_code
[i
].flags
;
354 tmp_stream
= nut
->frame_code
[i
].stream_id
;
355 tmp_mul
= nut
->frame_code
[i
].size_mul
;
356 tmp_size
= nut
->frame_code
[i
].size_lsb
;
357 // tmp_res = nut->frame_code[i].res;
358 tmp_head_idx
= nut
->frame_code
[i
].header_idx
;
360 for(j
=0; i
<256; j
++,i
++){
365 if(nut
->frame_code
[i
].pts_delta
!= tmp_pts
) break;
366 if(nut
->frame_code
[i
].flags
!= tmp_flags
) break;
367 if(nut
->frame_code
[i
].stream_id
!= tmp_stream
) break;
368 if(nut
->frame_code
[i
].size_mul
!= tmp_mul
) break;
369 if(nut
->frame_code
[i
].size_lsb
!= tmp_size
+j
) break;
370 // if(nut->frame_code[i].res != tmp_res ) break;
371 if(nut
->frame_code
[i
].header_idx
!= tmp_head_idx
) break;
373 if(j
!= tmp_mul
- tmp_size
) tmp_fields
=6;
375 put_v(bc
, tmp_flags
);
376 put_v(bc
, tmp_fields
);
377 if(tmp_fields
>0) put_s(bc
, tmp_pts
);
378 if(tmp_fields
>1) put_v(bc
, tmp_mul
);
379 if(tmp_fields
>2) put_v(bc
, tmp_stream
);
380 if(tmp_fields
>3) put_v(bc
, tmp_size
);
381 if(tmp_fields
>4) put_v(bc
, 0 /*tmp_res*/);
382 if(tmp_fields
>5) put_v(bc
, j
);
383 if(tmp_fields
>6) put_v(bc
, tmp_match
);
384 if(tmp_fields
>7) put_v(bc
, tmp_head_idx
);
386 put_v(bc
, nut
->header_count
-1);
387 for(i
=1; i
<nut
->header_count
; i
++){
388 put_v(bc
, nut
->header_len
[i
]);
389 put_buffer(bc
, nut
->header
[i
], nut
->header_len
[i
]);
393 static int write_streamheader(NUTContext
*nut
, ByteIOContext
*bc
, AVStream
*st
, int i
){
394 AVCodecContext
*codec
= st
->codec
;
396 switch(codec
->codec_type
){
397 case CODEC_TYPE_VIDEO
: put_v(bc
, 0); break;
398 case CODEC_TYPE_AUDIO
: put_v(bc
, 1); break;
399 case CODEC_TYPE_SUBTITLE
: put_v(bc
, 2); break;
400 default : put_v(bc
, 3); break;
403 if (codec
->codec_tag
){
404 put_le32(bc
, codec
->codec_tag
);
408 put_v(bc
, nut
->stream
[i
].time_base
- nut
->time_base
);
409 put_v(bc
, nut
->stream
[i
].msb_pts_shift
);
410 put_v(bc
, nut
->stream
[i
].max_pts_distance
);
411 put_v(bc
, codec
->has_b_frames
);
412 put_byte(bc
, 0); /* flags: 0x1 - fixed_fps, 0x2 - index_present */
414 put_v(bc
, codec
->extradata_size
);
415 put_buffer(bc
, codec
->extradata
, codec
->extradata_size
);
417 switch(codec
->codec_type
){
418 case CODEC_TYPE_AUDIO
:
419 put_v(bc
, codec
->sample_rate
);
421 put_v(bc
, codec
->channels
);
423 case CODEC_TYPE_VIDEO
:
424 put_v(bc
, codec
->width
);
425 put_v(bc
, codec
->height
);
427 if(st
->sample_aspect_ratio
.num
<=0 || st
->sample_aspect_ratio
.den
<=0){
431 put_v(bc
, st
->sample_aspect_ratio
.num
);
432 put_v(bc
, st
->sample_aspect_ratio
.den
);
434 put_v(bc
, 0); /* csp type -- unknown */
442 static int add_info(ByteIOContext
*bc
, const char *type
, const char *value
){
449 static int write_globalinfo(NUTContext
*nut
, ByteIOContext
*bc
){
450 AVFormatContext
*s
= nut
->avf
;
451 AVMetadataTag
*title
, *author
, *copyright
;
452 ByteIOContext
*dyn_bc
;
453 uint8_t *dyn_buf
=NULL
;
454 int count
=0, dyn_size
;
455 int ret
= url_open_dyn_buf(&dyn_bc
);
459 title
= av_metadata_get(s
->metadata
, "Title" , NULL
, 0);
460 author
= av_metadata_get(s
->metadata
, "Author" , NULL
, 0);
461 copyright
= av_metadata_get(s
->metadata
, "Copyright", NULL
, 0);
463 if(title
) count
+= add_info(dyn_bc
, "Title" , title
->value
);
464 if(author
) count
+= add_info(dyn_bc
, "Author" , author
->value
);
465 if(copyright
) count
+= add_info(dyn_bc
, "Copyright", copyright
->value
);
466 if(!(s
->streams
[0]->codec
->flags
& CODEC_FLAG_BITEXACT
))
467 count
+= add_info(dyn_bc
, "Encoder" , LIBAVFORMAT_IDENT
);
469 put_v(bc
, 0); //stream_if_plus1
470 put_v(bc
, 0); //chapter_id
471 put_v(bc
, 0); //timestamp_start
472 put_v(bc
, 0); //length
476 dyn_size
= url_close_dyn_buf(dyn_bc
, &dyn_buf
);
477 put_buffer(bc
, dyn_buf
, dyn_size
);
482 static int write_streaminfo(NUTContext
*nut
, ByteIOContext
*bc
, int stream_id
){
483 AVFormatContext
*s
= nut
->avf
;
484 AVStream
* st
= s
->streams
[stream_id
];
485 ByteIOContext
*dyn_bc
;
486 uint8_t *dyn_buf
=NULL
;
487 int count
=0, dyn_size
, i
;
488 int ret
= url_open_dyn_buf(&dyn_bc
);
492 for (i
=0; ff_nut_dispositions
[i
].flag
; ++i
) {
493 if (st
->disposition
& ff_nut_dispositions
[i
].flag
)
494 count
+= add_info(dyn_bc
, "Disposition", ff_nut_dispositions
[i
].str
);
496 dyn_size
= url_close_dyn_buf(dyn_bc
, &dyn_buf
);
499 put_v(bc
, stream_id
+ 1); //stream_id_plus1
500 put_v(bc
, 0); //chapter_id
501 put_v(bc
, 0); //timestamp_start
502 put_v(bc
, 0); //length
506 put_buffer(bc
, dyn_buf
, dyn_size
);
513 static int write_headers(NUTContext
*nut
, ByteIOContext
*bc
){
514 ByteIOContext
*dyn_bc
;
517 ret
= url_open_dyn_buf(&dyn_bc
);
520 write_mainheader(nut
, dyn_bc
);
521 put_packet(nut
, bc
, dyn_bc
, 1, MAIN_STARTCODE
);
523 for (i
=0; i
< nut
->avf
->nb_streams
; i
++){
524 ret
= url_open_dyn_buf(&dyn_bc
);
527 write_streamheader(nut
, dyn_bc
, nut
->avf
->streams
[i
], i
);
528 put_packet(nut
, bc
, dyn_bc
, 1, STREAM_STARTCODE
);
531 ret
= url_open_dyn_buf(&dyn_bc
);
534 write_globalinfo(nut
, dyn_bc
);
535 put_packet(nut
, bc
, dyn_bc
, 1, INFO_STARTCODE
);
537 for (i
= 0; i
< nut
->avf
->nb_streams
; i
++) {
538 ret
= url_open_dyn_buf(&dyn_bc
);
541 ret
= write_streaminfo(nut
, dyn_bc
, i
);
545 put_packet(nut
, bc
, dyn_bc
, 1, INFO_STARTCODE
);
548 url_close_dyn_buf(dyn_bc
, &buf
);
553 nut
->last_syncpoint_pos
= INT_MIN
;
558 static int write_header(AVFormatContext
*s
){
559 NUTContext
*nut
= s
->priv_data
;
560 ByteIOContext
*bc
= s
->pb
;
565 nut
->stream
= av_mallocz(sizeof(StreamContext
)*s
->nb_streams
);
566 nut
->time_base
= av_mallocz(sizeof(AVRational
)*s
->nb_streams
);
568 for(i
=0; i
<s
->nb_streams
; i
++){
569 AVStream
*st
= s
->streams
[i
];
571 AVRational time_base
;
572 ff_parse_specific_params(st
->codec
, &time_base
.den
, &ssize
, &time_base
.num
);
574 av_set_pts_info(st
, 64, time_base
.num
, time_base
.den
);
576 for(j
=0; j
<nut
->time_base_count
; j
++){
577 if(!memcmp(&time_base
, &nut
->time_base
[j
], sizeof(AVRational
))){
581 nut
->time_base
[j
]= time_base
;
582 nut
->stream
[i
].time_base
= &nut
->time_base
[j
];
583 if(j
==nut
->time_base_count
)
584 nut
->time_base_count
++;
586 if(av_q2d(time_base
) >= 0.001)
587 nut
->stream
[i
].msb_pts_shift
= 7;
589 nut
->stream
[i
].msb_pts_shift
= 14;
590 nut
->stream
[i
].max_pts_distance
= FFMAX(1/av_q2d(time_base
), 1);
593 nut
->max_distance
= MAX_DISTANCE
;
594 build_elision_headers(s
);
596 assert(nut
->frame_code
['N'].flags
== FLAG_INVALID
);
598 put_buffer(bc
, ID_STRING
, strlen(ID_STRING
));
601 write_headers(nut
, bc
);
603 put_flush_packet(bc
);
610 static int get_needed_flags(NUTContext
*nut
, StreamContext
*nus
, FrameCode
*fc
, AVPacket
*pkt
){
613 if(pkt
->flags
& PKT_FLAG_KEY
) flags
|= FLAG_KEY
;
614 if(pkt
->stream_index
!= fc
->stream_id
) flags
|= FLAG_STREAM_ID
;
615 if(pkt
->size
/ fc
->size_mul
) flags
|= FLAG_SIZE_MSB
;
616 if(pkt
->pts
- nus
->last_pts
!= fc
->pts_delta
) flags
|= FLAG_CODED_PTS
;
617 if(pkt
->size
> 2*nut
->max_distance
) flags
|= FLAG_CHECKSUM
;
618 if(FFABS(pkt
->pts
- nus
->last_pts
)
619 > nus
->max_pts_distance
) flags
|= FLAG_CHECKSUM
;
620 if( pkt
->size
< nut
->header_len
[fc
->header_idx
]
621 || (pkt
->size
> 4096 && fc
->header_idx
)
622 || memcmp(pkt
->data
, nut
->header
[fc
->header_idx
], nut
->header_len
[fc
->header_idx
]))
623 flags
|= FLAG_HEADER_IDX
;
625 return flags
| (fc
->flags
& FLAG_CODED
);
628 static int find_best_header_idx(NUTContext
*nut
, AVPacket
*pkt
){
636 for(i
=1; i
<nut
->header_count
; i
++){
637 if( pkt
->size
>= nut
->header_len
[i
]
638 && nut
->header_len
[i
] > best_len
639 && !memcmp(pkt
->data
, nut
->header
[i
], nut
->header_len
[i
])){
641 best_len
= nut
->header_len
[i
];
647 static int write_packet(AVFormatContext
*s
, AVPacket
*pkt
){
648 NUTContext
*nut
= s
->priv_data
;
649 StreamContext
*nus
= &nut
->stream
[pkt
->stream_index
];
650 ByteIOContext
*bc
= s
->pb
, *dyn_bc
;
653 int best_length
, frame_code
, flags
, needed_flags
, i
, header_idx
, best_header_idx
;
654 int key_frame
= !!(pkt
->flags
& PKT_FLAG_KEY
);
661 if(1LL<<(20+3*nut
->header_count
) <= url_ftell(bc
))
662 write_headers(nut
, bc
);
664 if(key_frame
&& !(nus
->last_flags
& FLAG_KEY
))
667 if(pkt
->size
+ 30/*FIXME check*/ + url_ftell(bc
) >= nut
->last_syncpoint_pos
+ nut
->max_distance
)
670 //FIXME: Ensure store_sp is 1 in the first place.
673 Syncpoint
*sp
, dummy
= {.pos
= INT64_MAX
};
675 ff_nut_reset_ts(nut
, *nus
->time_base
, pkt
->dts
);
676 for(i
=0; i
<s
->nb_streams
; i
++){
677 AVStream
*st
= s
->streams
[i
];
678 int64_t dts_tb
= av_rescale_rnd(pkt
->dts
,
679 nus
->time_base
->num
* (int64_t)nut
->stream
[i
].time_base
->den
,
680 nus
->time_base
->den
* (int64_t)nut
->stream
[i
].time_base
->num
,
682 int index
= av_index_search_timestamp(st
, dts_tb
, AVSEEK_FLAG_BACKWARD
);
683 if(index
>=0) dummy
.pos
= FFMIN(dummy
.pos
, st
->index_entries
[index
].pos
);
685 if(dummy
.pos
== INT64_MAX
)
687 sp
= av_tree_find(nut
->syncpoints
, &dummy
, ff_nut_sp_pos_cmp
, NULL
);
689 nut
->last_syncpoint_pos
= url_ftell(bc
);
690 ret
= url_open_dyn_buf(&dyn_bc
);
693 put_tt(nut
, nus
, dyn_bc
, pkt
->dts
);
694 put_v(dyn_bc
, sp
? (nut
->last_syncpoint_pos
- sp
->pos
)>>4 : 0);
695 put_packet(nut
, bc
, dyn_bc
, 1, SYNCPOINT_STARTCODE
);
697 ff_nut_add_sp(nut
, nut
->last_syncpoint_pos
, 0/*unused*/, pkt
->dts
);
699 assert(nus
->last_pts
!= AV_NOPTS_VALUE
);
701 coded_pts
= pkt
->pts
& ((1<<nus
->msb_pts_shift
)-1);
702 if(ff_lsb2full(nus
, coded_pts
) != pkt
->pts
)
703 coded_pts
= pkt
->pts
+ (1<<nus
->msb_pts_shift
);
705 best_header_idx
= find_best_header_idx(nut
, pkt
);
709 for(i
=0; i
<256; i
++){
711 FrameCode
*fc
= &nut
->frame_code
[i
];
712 int flags
= fc
->flags
;
714 if(flags
& FLAG_INVALID
)
716 needed_flags
= get_needed_flags(nut
, nus
, fc
, pkt
);
718 if(flags
& FLAG_CODED
){
720 flags
= needed_flags
;
723 if((flags
& needed_flags
) != needed_flags
)
726 if((flags
^ needed_flags
) & FLAG_KEY
)
729 if(flags
& FLAG_STREAM_ID
)
730 length
+= get_length(pkt
->stream_index
);
732 if(pkt
->size
% fc
->size_mul
!= fc
->size_lsb
)
734 if(flags
& FLAG_SIZE_MSB
)
735 length
+= get_length(pkt
->size
/ fc
->size_mul
);
737 if(flags
& FLAG_CHECKSUM
)
740 if(flags
& FLAG_CODED_PTS
)
741 length
+= get_length(coded_pts
);
743 if( (flags
& FLAG_CODED
)
744 && nut
->header_len
[best_header_idx
] > nut
->header_len
[fc
->header_idx
]+1){
745 flags
|= FLAG_HEADER_IDX
;
748 if(flags
& FLAG_HEADER_IDX
){
749 length
+= 1 - nut
->header_len
[best_header_idx
];
751 length
-= nut
->header_len
[fc
->header_idx
];
755 length
+= !(flags
& FLAG_CODED_PTS
);
756 length
+= !(flags
& FLAG_CHECKSUM
);
758 if(length
< best_length
){
763 assert(frame_code
!= -1);
764 fc
= &nut
->frame_code
[frame_code
];
766 needed_flags
= get_needed_flags(nut
, nus
, fc
, pkt
);
767 header_idx
= fc
->header_idx
;
769 init_checksum(bc
, ff_crc04C11DB7_update
, 0);
770 put_byte(bc
, frame_code
);
771 if(flags
& FLAG_CODED
){
772 put_v(bc
, (flags
^needed_flags
) & ~(FLAG_CODED
));
773 flags
= needed_flags
;
775 if(flags
& FLAG_STREAM_ID
) put_v(bc
, pkt
->stream_index
);
776 if(flags
& FLAG_CODED_PTS
) put_v(bc
, coded_pts
);
777 if(flags
& FLAG_SIZE_MSB
) put_v(bc
, pkt
->size
/ fc
->size_mul
);
778 if(flags
& FLAG_HEADER_IDX
) put_v(bc
, header_idx
= best_header_idx
);
780 if(flags
& FLAG_CHECKSUM
) put_le32(bc
, get_checksum(bc
));
781 else get_checksum(bc
);
783 put_buffer(bc
, pkt
->data
+ nut
->header_len
[header_idx
], pkt
->size
- nut
->header_len
[header_idx
]);
784 nus
->last_flags
= flags
;
785 nus
->last_pts
= pkt
->pts
;
787 //FIXME just store one per syncpoint
790 s
->streams
[pkt
->stream_index
],
791 nut
->last_syncpoint_pos
,
800 static int write_trailer(AVFormatContext
*s
){
801 NUTContext
*nut
= s
->priv_data
;
802 ByteIOContext
*bc
= s
->pb
;
804 while(nut
->header_count
<3)
805 write_headers(nut
, bc
);
806 put_flush_packet(bc
);
811 AVOutputFormat nut_muxer
= {
813 NULL_IF_CONFIG_SMALL("NUT format"),
819 #elif CONFIG_LIBMP3LAME
828 .flags
= AVFMT_GLOBALHEADER
| AVFMT_VARIABLE_FPS
,
829 .codec_tag
= (const AVCodecTag
* const []){ff_codec_bmp_tags
, ff_codec_wav_tags
, ff_nut_subtitle_tags
, 0},