?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Major oops. Reverts previous two check-ins, which ended up in tags/0.9.0 instead...
[HandBrake.git] / libhb / stream.c
blob1e8e3364790747f5c5f81d5723813898833f193f
1 /* $Id$
2
3 This file is part of the HandBrake source code.
4 Homepage: <http://handbrake.m0k.org/>.
5 It may be used under the terms of the GNU General Public License. */
6
7 #include "hb.h"
8 #include "lang.h"
9 #include "a52dec/a52.h"
10
11 #include <string.h>
12
13 #define min(a, b) a < b ? a : b
14
15 typedef enum { hb_stream_type_unknown = 0, hb_stream_type_transport, hb_stream_type_program } hb_stream_type_t;
16
17 #define kMaxNumberDecodeStreams 8
18 #define kMaxNumberVideoPIDS 16
19 #define kMaxNumberAudioPIDS 32
20 //#define kVideoStream 0
21 //#define kAudioStream 1
22 #define kNumDecodeBuffers 2
23
24 #define CLOCKRATE ((int64_t)27000000) // MPEG System clock rate
25 #define STREAMRATE ((int64_t)2401587) // Original HD stream rate 19.2 Mbps
26 #define DEMUX (((int)STREAMRATE * 8) / 50)// Demux value for HD content STREAMRATE / 50
27
28 struct hb_stream_s
29 {
30 char * path;
31 FILE * file_handle;
32 hb_stream_type_t stream_type;
33
34 int ps_current_write_buffer_index;
35 int ps_current_read_buffer_index;
36
37 struct {
38 int size;
39 int len;
40 int read_pos;
41 int write_pos;
42 unsigned char * data;
43 } ps_decode_buffer[kNumDecodeBuffers];
44
45 struct {
46 int lang_code;
47 int flags;
48 int rate;
49 int bitrate;
50 } a52_info[kMaxNumberAudioPIDS];
51
52 int ts_video_pids[kMaxNumberVideoPIDS];
53 int ts_audio_pids[kMaxNumberAudioPIDS];
54
55 int ts_number_video_pids;
56 int ts_number_audio_pids;
57 int ts_selected_audio_pid_index;
58
59 unsigned char* ts_packetbuf[kMaxNumberDecodeStreams];
60 int ts_packetpos[kMaxNumberDecodeStreams];
61 // int ts_bufpackets[kMaxNumberDecodeStreams];
62 int ts_foundfirst[kMaxNumberDecodeStreams];
63 int ts_skipbad[kMaxNumberDecodeStreams];
64 int ts_streamcont[kMaxNumberDecodeStreams];
65 int ts_streamid[kMaxNumberDecodeStreams];
66 int ts_audio_stream_type[kMaxNumberAudioPIDS];
67
68 FILE *debug_output;
69 };
70
71 /***********************************************************************
72 * Local prototypes
73 **********************************************************************/
74 static void hb_stream_duration(hb_stream_t *stream, hb_title_t *inTitle);
75 static void hb_ts_stream_init(hb_stream_t *stream);
76 static void hb_ts_stream_find_pids(hb_stream_t *stream);
77 static void hb_ts_stream_decode(hb_stream_t *stream);
78 static void hb_ts_stream_reset(hb_stream_t *stream);
79 static void hb_stream_put_back(hb_stream_t *stream, int i);
80 static void hb_stream_set_audio_id_and_codec(hb_stream_t *stream, hb_audio_t *audio);
81
82 int hb_stream_is_stream_type( char * path )
83 {
84 if ((strstr(path,".mpg") != NULL) ||
85 (strstr(path,".vob") != NULL) ||
86 (strstr(path,".ts") != NULL) ||
87 (strstr(path, ".m2t") != NULL))
88 {
89 return 1;
90 }
91 else
92 return 0;
93 }
94
95 /***********************************************************************
96 * hb_stream_open
97 ***********************************************************************
98 *
99 **********************************************************************/
100 hb_stream_t * hb_stream_open( char * path )
101 {
102 hb_stream_t * d;
103
104 d = calloc( sizeof( hb_stream_t ), 1 );
105
106 /* Open device */
107 if( !( d->file_handle = fopen( path, "rb" ) ) )
108 {
109 hb_log( "hb_stream_open: fopen failed (%s)", path );
110 goto fail;
111 }
112
113 d->path = strdup( path );
114
115 if ( ( strstr(d->path,".ts") != NULL) || ( strstr(d->path,".m2t") != NULL))
116 {
117 d->stream_type = hb_stream_type_transport;
118 hb_ts_stream_init(d);
119 }
120 else if (( strstr(d->path,".mpg") != NULL) || ( strstr(d->path,".vob") != NULL))
121 {
122 d->stream_type = hb_stream_type_program;
123 }
124
125 return d;
126
127 fail:
128 free( d );
129 return NULL;
130 }
131
132 /***********************************************************************
133 * hb_stream_close
134 ***********************************************************************
135 * Closes and frees everything
136 **********************************************************************/
137 void hb_stream_close( hb_stream_t ** _d )
138 {
139 hb_stream_t * d = *_d;
140
141 if( d->file_handle )
142 {
143 fclose( d->file_handle );
144 d->file_handle = NULL;
145 }
146
147 if (d->debug_output)
148 {
149 fclose(d->debug_output);
150 d->debug_output = NULL;
151 }
152
153 int i=0;
154 for (i = 0; i < kNumDecodeBuffers; i++)
155 {
156 if (d->ps_decode_buffer[i].data)
157 {
158 free(d->ps_decode_buffer[i].data);
159 d->ps_decode_buffer[i].data = NULL;
160 }
161 }
162
163 for (i = 0; i < kMaxNumberDecodeStreams; i++)
164 {
165 if (d->ts_packetbuf[i])
166 {
167 free(d->ts_packetbuf[i]);
168 d->ts_packetbuf[i] = NULL;
169 }
170 }
171
172 free( d );
173 *_d = NULL;
174 }
175
176 /***********************************************************************
177 * hb_ps_stream_title_scan
178 ***********************************************************************
179 *
180 **********************************************************************/
181 hb_title_t * hb_stream_title_scan(hb_stream_t *stream)
182 {
183 // 'Barebones Title'
184 hb_title_t *aTitle = hb_title_init( stream->path, 0 );
185
186 // Copy part of the stream path to the title name
187 char *sep = strrchr(stream->path, '/');
188 if (sep)
189 strcpy(aTitle->name, sep+1);
190 char *dot_term = strrchr(aTitle->name, '.');
191 if (dot_term)
192 *dot_term = '\0';
193
194 // Height, width, rate and aspect ratio information is filled in when the previews are built
195
196 hb_stream_duration(stream, aTitle);
197
198 // One Chapter
199 hb_chapter_t * chapter;
200 chapter = calloc( sizeof( hb_chapter_t ), 1 );
201 chapter->index = 1;
202 chapter->duration = aTitle->duration;
203 chapter->hours = aTitle->hours;
204 chapter->minutes = aTitle->minutes;
205 chapter->seconds = aTitle->seconds;
206 hb_list_add( aTitle->list_chapter, chapter );
207
208 int i=0, num_audio_tracks = 1;
209
210 if (stream->stream_type == hb_stream_type_transport)
211 {
212 num_audio_tracks = stream->ts_number_audio_pids;
213 }
214
215 for (i=0; i < num_audio_tracks ; i++)
216 {
217 // Basic AC-3 Audio track
218 hb_audio_t * audio;
219 audio = calloc( sizeof( hb_audio_t ), 1 );
220
221 audio->source_pid = stream->ts_audio_pids[i];
222
223 hb_stream_set_audio_id_and_codec(stream, audio);
224
225 hb_list_add( aTitle->list_audio, audio );
226 }
227
228 return aTitle;
229 }
230
231 /***********************************************************************
232 * hb_stream_duration
233 ***********************************************************************
234 *
235 **********************************************************************/
236 void hb_stream_duration(hb_stream_t *stream, hb_title_t *inTitle)
237 {
238 // VOB Files often have exceedingly unusual PTS values in them - they will progress for a while
239 // and then reset without warning !
240 if (strstr(stream->path,".vob") != NULL)
241 {
242 // So we'll use a 'fake duration' that should give enough time !
243 int64_t duration = 4 * 3600 * 90000;
244 inTitle->duration = duration; //90LL * dvdtime2msec( &d->pgc->playback_time );
245 inTitle->hours = inTitle->duration / 90000 / 3600;
246 inTitle->minutes = ( ( inTitle->duration / 90000 ) % 3600 ) / 60;
247 inTitle->seconds = ( inTitle->duration / 90000 ) % 60;
248 return;
249 }
250
251 unsigned char *buf = (unsigned char *) malloc(4096);
252 int done = 0;
253 off_t cur_pos;
254 int64_t first_pts = 0, last_pts = 0;
255
256 // To calculate the duration we look for the first and last presentation time stamps in the stream for video data
257 // and then use the delta
258 while (!done)
259 {
260 cur_pos = ftello(stream->file_handle);
261 if (fread(buf, 4096, 1, stream->file_handle) == 1)
262 {
263 int i=0;
264 for (i=0; (i <= 4092) && !done; i++)
265 {
266 if ((buf[i] == 0x00) && (buf[i+1] == 0x00) && (buf[i+2] == 0x01) && (buf[i+3] == 0xe0)) // Found a Video Stream
267 {
268 // Now look for a PTS field - we need to make sure we have enough space so we back up a little and read
269 // some more data
270 fseeko(stream->file_handle, cur_pos + i, SEEK_SET);
271 if (fread(buf, 4096, 1, stream->file_handle) == 1)
272 {
273 int has_pts = ( ( buf[7] >> 6 ) & 0x2 ) ? 1 : 0;
274 if (has_pts)
275 {
276 first_pts = ( ( ( (uint64_t) buf[9] >> 1 ) & 0x7 ) << 30 ) +
277 ( buf[10] << 22 ) +
278 ( ( buf[11] >> 1 ) << 15 ) +
279 ( buf[12] << 7 ) +
280 ( buf[13] >> 1 );
281 done = 1;
282 }
283 else
284 {
285 fseeko(stream->file_handle, cur_pos, SEEK_SET);
286 fread(buf, 4096, 1, stream->file_handle);
287 }
288 }
289 }
290 }
291 }
292 else
293 done = 1; // End of data;
294 }
295
296 // Now work back from the end of the stream
297 fseeko(stream->file_handle,0 ,SEEK_END);
298
299 done = 0;
300 while (!done)
301 {
302 // Back up a little
303 if (fseeko(stream->file_handle, -4096, SEEK_CUR) < 0)
304 {
305 done = 1;
306 break;
307 }
308
309 cur_pos = ftello(stream->file_handle);
310 if (fread(buf, 4096, 1, stream->file_handle) == 1)
311 {
312 int i=0;
313 for (i=4092; (i >= 0) && !done; i--)
314 {
315 if ((buf[i] == 0x00) && (buf[i+1] == 0x00) && (buf[i+2] == 0x01) && (buf[i+3] == 0xe0)) // Found a Video Stream
316 {
317 // Now look for a PTS field - we need to make sure we have enough space so we back up a little and read
318 // some more data
319 fseeko(stream->file_handle, cur_pos + i, SEEK_SET);
320 fread(buf, 1, 4096, stream->file_handle);
321
322 unsigned char pts_dts_flag = buf[7];
323
324 int has_pts = ( ( buf[7] >> 6 ) & 0x2 ) ? 1 : 0;
325 if (has_pts)
326 {
327 last_pts = ( ( ( (uint64_t) buf[9] >> 1 ) & 0x7 ) << 30 ) +
328 ( buf[10] << 22 ) +
329 ( ( buf[11] >> 1 ) << 15 ) +
330 ( buf[12] << 7 ) +
331 ( buf[13] >> 1 );
332
333 done = 1;
334 }
335 else
336 {
337 // Re Read the original data and carry on (i is still valid in the old buffer)
338 fseeko(stream->file_handle, cur_pos, SEEK_SET);
339 fread(buf, 4096, 1, stream->file_handle);
340 }
341 }
342 }
343 fseeko(stream->file_handle, -4096, SEEK_CUR); // 'Undo' the last read
344 }
345 else
346 done = 1; // End of data;
347 }
348 free(buf);
349
350 int64_t duration = last_pts - first_pts;
351 inTitle->duration = duration; //90LL * dvdtime2msec( &d->pgc->playback_time );
352 inTitle->hours = inTitle->duration / 90000 / 3600;
353 inTitle->minutes = ( ( inTitle->duration / 90000 ) % 3600 ) / 60;
354 inTitle->seconds = ( inTitle->duration / 90000 ) % 60;
355
356 }
357
358 /***********************************************************************
359 * hb_stream_read
360 ***********************************************************************
361 *
362 **********************************************************************/
363 int hb_stream_read( hb_stream_t * src_stream, hb_buffer_t * b )
364 {
365 if (src_stream->stream_type == hb_stream_type_program)
366 {
367 size_t amt_read;
368 amt_read = fread(b->data, HB_DVD_READ_BUFFER_SIZE, 1, src_stream->file_handle);
369 if (amt_read > 0)
370 return 1;
371 else
372 return 0;
373 }
374 else if (src_stream->stream_type == hb_stream_type_transport)
375 {
376 int read_buffer_index = src_stream->ps_current_read_buffer_index;
377
378 // Transport streams are a little more complex - we might be able to just
379 // read from the transport stream conversion buffer (if there's enough data)
380 // or we may need to transfer what's left and fill it again.
381 if (src_stream->ps_decode_buffer[read_buffer_index].len - src_stream->ps_decode_buffer[read_buffer_index].read_pos > HB_DVD_READ_BUFFER_SIZE)
382 {
383 memcpy(b->data, src_stream->ps_decode_buffer[read_buffer_index].data + src_stream->ps_decode_buffer[read_buffer_index].read_pos,HB_DVD_READ_BUFFER_SIZE);
384 src_stream->ps_decode_buffer[read_buffer_index].read_pos += HB_DVD_READ_BUFFER_SIZE;
385 return 1;
386 }
387 else
388 {
389 // Not quite enough data in the buffer - transfer what is present, fill the buffer and then
390 // transfer what's still needed.
391 int transfer_size = HB_DVD_READ_BUFFER_SIZE;
392 int amt_avail_to_transfer = src_stream->ps_decode_buffer[read_buffer_index].len - src_stream->ps_decode_buffer[read_buffer_index].read_pos;
393 memcpy(b->data, src_stream->ps_decode_buffer[read_buffer_index].data + src_stream->ps_decode_buffer[read_buffer_index].read_pos, amt_avail_to_transfer);
394 transfer_size -= amt_avail_to_transfer;
395 src_stream->ps_decode_buffer[read_buffer_index].read_pos += amt_avail_to_transfer;
396
397 // Give up this buffer - decoding may well need it, and we're done
398 src_stream->ps_decode_buffer[read_buffer_index].write_pos = 0;
399 src_stream->ps_decode_buffer[read_buffer_index].len = 0;
400
401 // Fill the buffer
402 hb_ts_stream_decode(src_stream);
403
404 // Decoding will almost certainly have changed the current read buffer index
405 read_buffer_index = src_stream->ps_current_read_buffer_index;
406
407 if (src_stream->ps_decode_buffer[read_buffer_index].len == 0)
408 {
409 hb_log("hb_stream_read - buffer after decode has zero length data");
410 return 0;
411 }
412
413 // Read the bit we still need
414 memcpy(b->data+amt_avail_to_transfer, src_stream->ps_decode_buffer[read_buffer_index].data + src_stream->ps_decode_buffer[read_buffer_index].read_pos,transfer_size);
415 src_stream->ps_decode_buffer[read_buffer_index].read_pos += transfer_size;
416
417 return 1;
418 }
419 }
420 else
421 return 0;
422 }
423
424 /***********************************************************************
425 * hb_stream_seek
426 ***********************************************************************
427 *
428 **********************************************************************/
429 int hb_stream_seek( hb_stream_t * src_stream, float f )
430 {
431 off_t stream_size, cur_pos, new_pos;
432 double pos_ratio = f;
433 cur_pos = ftello(src_stream->file_handle);
434 fseeko(src_stream->file_handle,0 ,SEEK_END);
435 stream_size = ftello(src_stream->file_handle);
436 new_pos = (off_t) ((double) (stream_size) * pos_ratio);
437 int r = fseeko(src_stream->file_handle, new_pos, SEEK_SET);
438
439 if (r == -1)
440 {
441 fseeko(src_stream->file_handle, cur_pos, SEEK_SET);
442 return 0;
443 }
444
445 if (src_stream->stream_type == hb_stream_type_transport)
446 {
447 // We need to drop the current decoder output and move
448 // forwards to the next transport stream packet.
449 hb_ts_stream_reset(src_stream);
450 }
451
452 // Now we must scan forwards for a valid start code (0x000001BA)
453 int done = 0;
454 hb_buffer_t *buf = hb_buffer_init(HB_DVD_READ_BUFFER_SIZE);
455 while (!done)
456 {
457 if (hb_stream_read(src_stream,buf) == 1)
458 {
459 int i=0;
460 for (i=0; (i <= HB_DVD_READ_BUFFER_SIZE-4) && (!done); i++)
461 {
462 if ((buf->data[i] == 0x00) && (buf->data[i+1] == 0x00) && (buf->data[i+2] == 0x01) && (buf->data[i+3] == 0xba))
463 {
464 done = 1;
465 // 'Put Back' the data we've just read (up to this point)
466 hb_stream_put_back(src_stream, i);
467 }
468 }
469 }
470 else
471 done = 1; // End of data;
472 }
473 hb_buffer_close(&buf);
474 return 1;
475 }
476
477 /***********************************************************************
478 * hb_stream_set_audio_id_and_codec
479 ***********************************************************************
480 *
481 **********************************************************************/
482 void hb_stream_set_audio_id_and_codec(hb_stream_t *stream, hb_audio_t *audio)
483 {
484 off_t cur_pos;
485 cur_pos = ftello(stream->file_handle);
486 int done = 0;
487 hb_buffer_t *buf = NULL;
488
489 int cur_audio_pid_index = stream->ts_selected_audio_pid_index;
490
491 if (stream->stream_type == hb_stream_type_transport)
492 {
493 int i=0;
494 for (i=0; i < stream->ts_number_audio_pids; i++)
495 {
496 if (stream->ts_audio_pids[i] == audio->source_pid)
497 {
498 stream->ts_selected_audio_pid_index = i;
499 break;
500 }
501 }
502 }
503
504 //Start at the beginning of the stream
505 hb_stream_seek(stream, 0.0f);
506 // fseeko(stream->file_handle,0 ,SEEK_SET);
507
508 // Now we must scan forwards for a valid audio start code (0x000001xx)
509 buf = hb_buffer_init(HB_DVD_READ_BUFFER_SIZE);
510 while (!done)
511 {
512 // if (fread(buf->data,4096,1,stream->file_handle) == 1)
513 if (hb_stream_read(stream, buf) == 1)
514 {
515 int i=0;
516 for (i=0; (i <= HB_DVD_READ_BUFFER_SIZE-4) && (!done); i++)
517 {
518 if ((buf->data[i] == 0x00) && (buf->data[i+1] == 0x00) && (buf->data[i+2] == 0x01))
519 {
520 if (buf->data[i+3] == 0xbd)
521 {
522 audio->id = 0x80bd;
523 audio->codec = HB_ACODEC_AC3;
524 done = 1;
525 }
526 else if ((buf->data[i+3] & 0xe0) == 0xc0)
527 {
528 audio->id = buf->data[i+3];
529 audio->codec = HB_ACODEC_MPGA;
530 done = 1;
531 }
532 }
533 }
534 }
535 else
536 done = 1; // End of data;
537 }
538 hb_buffer_close(&buf);
539
540 fseeko(stream->file_handle, cur_pos, SEEK_SET);
541
542 stream->ts_selected_audio_pid_index = cur_audio_pid_index;
543 }
544
545 /***********************************************************************
546 * hb_stream_update_audio
547 ***********************************************************************
548 *
549 **********************************************************************/
550 void hb_stream_update_audio(hb_stream_t *stream, hb_audio_t *audio)
551 {
552 iso639_lang_t *lang;
553
554 if (stream->stream_type == hb_stream_type_program)
555 {
556 lang = lang_for_code(0x0000);
557 }
558 else if (stream->stream_type == hb_stream_type_transport)
559 {
560 // Find the audio stream info for this PID
561 int i=0;
562 for (i=0; i < stream->ts_number_audio_pids; i++)
563 {
564 if (stream->ts_audio_pids[i] == audio->source_pid)
565 break;
566 }
567 if (i == stream->ts_number_audio_pids)
568 {
569 hb_log("hb_stream_update_audio - cannot find PID 0x%x (%d) in ts_audio_pids list !", audio->source_pid, audio->source_pid);
570 return;
571 }
572
573 lang = lang_for_code(stream->a52_info[i].lang_code);
574 audio->rate = stream->a52_info[i].rate;
575 audio->bitrate = stream->a52_info[i].bitrate;
576 audio->config.a52.ac3flags = audio->ac3flags = stream->a52_info[i].flags;
577
578 }
579
580 switch( audio->ac3flags & A52_CHANNEL_MASK )
581 {
582 /* mono sources */
583 case A52_MONO:
584 case A52_CHANNEL1:
585 case A52_CHANNEL2:
586 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_MONO;
587 break;
588 /* stereo input */
589 case A52_CHANNEL:
590 case A52_STEREO:
591 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
592 break;
593 /* dolby (DPL1 aka Dolby Surround = 4.0 matrix-encoded) input */
594 case A52_DOLBY:
595 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_DOLBY;
596 break;
597 /* 3F/2R input */
598 case A52_3F2R:
599 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F2R;
600 break;
601 /* 3F/1R input */
602 case A52_3F1R:
603 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F1R;
604 break;
605 /* other inputs */
606 case A52_3F:
607 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_3F;
608 break;
609 case A52_2F1R:
610 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_2F1R;
611 break;
612 case A52_2F2R:
613 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_2F2R;
614 break;
615 /* unknown */
616 default:
617 audio->input_channel_layout = HB_INPUT_CH_LAYOUT_STEREO;
618 }
619
620 /* add in our own LFE flag if the source has LFE */
621 if (audio->ac3flags & A52_LFE)
622 {
623 audio->input_channel_layout = audio->input_channel_layout | HB_INPUT_CH_LAYOUT_HAS_LFE;
624 }
625
626 snprintf( audio->lang, sizeof( audio->lang ), "%s (%s)", strlen(lang->native_name) ? lang->native_name : lang->eng_name,
627 audio->codec == HB_ACODEC_AC3 ? "AC3" : ( audio->codec == HB_ACODEC_MPGA ? "MPEG" : "LPCM" ) );
628 snprintf( audio->lang_simple, sizeof( audio->lang_simple ), "%s", strlen(lang->native_name) ? lang->native_name : lang->eng_name );
629 snprintf( audio->iso639_2, sizeof( audio->iso639_2 ), "%s", lang->iso639_2);
630
631 if ( (audio->ac3flags & A52_CHANNEL_MASK) == A52_DOLBY ) {
632 sprintf( audio->lang + strlen( audio->lang ),
633 " (Dolby Surround)" );
634 } else {
635 sprintf( audio->lang + strlen( audio->lang ),
636 " (%d.%d ch)",
637 HB_INPUT_CH_LAYOUT_GET_DISCRETE_FRONT_COUNT(audio->input_channel_layout) +
638 HB_INPUT_CH_LAYOUT_GET_DISCRETE_REAR_COUNT(audio->input_channel_layout),
639 HB_INPUT_CH_LAYOUT_GET_DISCRETE_LFE_COUNT(audio->input_channel_layout));
640 }
641
642 hb_log( "hb_stream_update_audio: id=%x, lang=%s, 3cc=%s, rate = %d, bitrate = %d, flags = 0x%x (%d)", audio->id, audio->lang, audio->iso639_2, audio->rate, audio->bitrate, audio->ac3flags, audio->ac3flags );
643
644 }
645
646 void hb_stream_set_selected_audio_pid_index(hb_stream_t *stream, int i)
647 {
648 stream->ts_selected_audio_pid_index = i;
649 }
650
651 /***********************************************************************
652 * hb_stream_put_back
653 ***********************************************************************
654 *
655 **********************************************************************/
656 static void hb_stream_put_back(hb_stream_t *stream, int i)
657 {
658 if (stream->stream_type == hb_stream_type_program)
659 {
660 // Program streams are pretty easy - we just reposition the source file
661 // pointer
662 fseeko(stream->file_handle, -(HB_DVD_READ_BUFFER_SIZE-i), SEEK_CUR);
663 }
664 else if (stream->stream_type == hb_stream_type_transport)
665 {
666 int read_buffer_index = stream->ps_current_read_buffer_index;
667
668 // Transport streams are a little more tricky - so long as the
669 // amount to back up is still within the current decode buffer
670 // we can just adjust the read pos.
671 if (stream->ps_decode_buffer[read_buffer_index].read_pos - i > 0)
672 {
673 stream->ps_decode_buffer[read_buffer_index].read_pos -= i;
674 }
675 else
676 fprintf(stderr, "hb_stream_put_back - trying to step beyond the start of the buffer, read_pos = %d amt to put back = %d\n", stream->ps_decode_buffer[read_buffer_index].read_pos, i);
677 }
678 }
679
680
681 /***********************************************************************
682 * hb_ts_stream_init
683 ***********************************************************************
684 *
685 **********************************************************************/
686 #define PS_DECODE_BUFFER_SIZE ( 1024 * 1024 * 4)
687
688 static void hb_ts_stream_init(hb_stream_t *stream)
689 {
690 // Output Program Stream
691 int i=0;
692 for (i=0; i < kNumDecodeBuffers; i++)
693 {
694 stream->ps_decode_buffer[i].data = (unsigned char *) malloc(PS_DECODE_BUFFER_SIZE);
695 stream->ps_decode_buffer[i].read_pos = 0;
696 stream->ps_decode_buffer[i].size = PS_DECODE_BUFFER_SIZE;
697 stream->ps_decode_buffer[i].len = 0;
698 stream->ps_decode_buffer[i].write_pos = 0;
699 }
700
701 for (i=0; i < kMaxNumberDecodeStreams; i++)
702 {
703 stream->ts_streamcont[i] = -1;
704 }
705
706 stream->ps_current_write_buffer_index = 0;
707 stream->ps_current_read_buffer_index = 1;
708
709 // This is the index (in ts_audio_pids) of the selected
710 // output stream. It should not be set until after all the
711 // pids in the stream have been discovered.
712 stream->ts_selected_audio_pid_index = -1;
713
714 stream->debug_output = fopen("/Users/awk/Desktop/hb_debug.mpg", "wb");
715
716 // Find the audio and video pids in the stream
717 hb_ts_stream_find_pids(stream);
718
719 for (i=0; i < stream->ts_number_video_pids; i++)
720 {
721 // In progress audio/video data during the transport stream -> program stream processing
722 stream->ts_packetbuf[i] = (unsigned char *) malloc(1024 * 1024);
723 stream->ts_streamid[i] = 0xE0; // Stream is Video
724 }
725
726 for (i = stream->ts_number_video_pids; i < stream->ts_number_video_pids + stream->ts_number_audio_pids; i++)
727 {
728 stream->ts_packetbuf[i] = (unsigned char *) malloc(1024 * 1024);
729 stream->ts_streamid[i] = 0xBD; // Stream 1 is AC-3 Audio
730 }
731 }
732
733 // ------------------------------------------------------------------------------------
734
735 off_t align_to_next_packet(FILE* f)
736 {
737 unsigned char buf[188*20];
738
739 off_t start = ftello(f);
740 off_t pos = 0;
741
742 if (fread(buf, 188*20, 1, f) == 1)
743 {
744 int found = 0;
745 while (!found && (pos < 188))
746 {
747 found = 1;
748 int i = 0;
749 for (i = 0; i < 188*20; i += 188)
750 {
751 unsigned char c = buf[pos+i];
752 // Check sync byte
753 if ((c != 0x47) && (c != 0x72) && (c != 0x29))
754 {
755 // this offset failed, try next
756 found = 0;
757 pos++;
758 break;
759 }
760 }
761 }
762 }
763
764 if (pos == 188)
765 pos = 0; // failed to find anything!!!!!?
766
767 fseek(f, start+pos, SEEK_SET);
768
769 return pos;
770 }
771
772 // ------------------------------------------------------------------------------------
773
774 int bitpos = 0;
775 unsigned int bitval = 0;
776 unsigned char* bitbuf = NULL;
777 unsigned int bitmask[] = {
778 0x0,0x1,0x3,0x7,0xf,0x1f,0x3f,0x7f,0xff,
779 0x1ff,0x3ff,0x7ff,0xfff,0x1fff,0x3fff,0x7fff,0xffff,
780 0x1ffff,0x3ffff,0x7ffff,0xfffff,0x1fffff,0x3fffff,0x7fffff,0xffffff,
781 0x1ffffff,0x3ffffff,0x7ffffff,0xfffffff,0x1fffffff,0x3fffffff,0x7fffffff,0xffffffff};
782
783 static inline void set_buf(unsigned char* buf, int bufsize, int clear)
784 {
785 bitpos = 0;
786 bitbuf = buf;
787 bitval = (bitbuf[0] << 24) | (bitbuf[1] << 16) | (bitbuf[2] << 8) | bitbuf[3];
788 if (clear)
789 memset(bitbuf, 0, bufsize);
790 }
791
792 static inline int buf_size()
793 {
794 return bitpos >> 3;
795 }
796
797 static inline void set_bits(unsigned int val, int bits)
798 {
799 val &= bitmask[bits];
800
801 while (bits > 0)
802 {
803 int bitsleft = (8 - (bitpos & 7));
804 if (bits >= bitsleft)
805 {
806 bitbuf[bitpos >> 3] |= val >> (bits - bitsleft);
807 bitpos += bitsleft;
808 bits -= bitsleft;
809 val &= bitmask[bits];
810 }
811 else
812 {
813 bitbuf[bitpos >> 3] |= val << (bitsleft - bits);
814 bitpos += bits;
815 bits = 0;
816 }
817 }
818 }
819
820 static inline unsigned int get_bits(int bits)
821 {
822 unsigned int val;
823 int left = 32 - (bitpos & 31);
824
825 if (bits < left)
826 {
827 val = (bitval >> (left - bits)) & bitmask[bits];
828 bitpos += bits;
829 }
830 else
831 {
832 val = (bitval & bitmask[left]) << (bits - left);
833 bitpos += left;
834 bits -= left;
835
836 int pos = bitpos >> 3;
837 bitval = (bitbuf[pos] << 24) | (bitbuf[pos + 1] << 16) | (bitbuf[pos + 2] << 8) | bitbuf[pos + 3];
838
839 if (bits > 0)
840 {
841 val |= (bitval >> (32 - bits)) & bitmask[bits];
842 bitpos += bits;
843 }
844 }
845
846 return val;
847 }
848
849 // ------------------------------------------------------------------------------------
850
851 int decode_program_map(unsigned char *buf, hb_stream_t *stream)
852 {
853 unsigned char tablebuf[1024];
854 unsigned int tablepos = 0;
855
856 int reading = 0;
857
858
859 // Get adaption header info
860 int adapt_len = 0;
861 int adaption = (buf[3] & 0x30) >> 4;
862 if (adaption == 0)
863 return 0;
864 else if (adaption == 0x2)
865 adapt_len = 184;
866 else if (adaption == 0x3)
867 adapt_len = buf[4] + 1;
868 if (adapt_len > 184)
869 return 0;
870
871 // Get pointer length
872 int pointer_len = buf[4 + adapt_len] + 1;
873
874 // Get payload start indicator
875 int start;
876 start = (buf[1] & 0x40) != 0;
877
878 if (start)
879 reading = 1;
880
881 // Add the payload for this packet to the current buffer
882 if (reading && (184 - adapt_len) > 0)
883 {
884 if (tablepos + 184 - adapt_len - pointer_len > 1024)
885 {
886 hb_log("decode_program_map - Bad program section length (> 1024)");
887 return 0;
888 }
889 memcpy(tablebuf + tablepos, buf + 4 + adapt_len + pointer_len, 184 - adapt_len - pointer_len);
890 tablepos += 184 - adapt_len - pointer_len;
891 }
892
893 if (start && reading)
894 {
895 int done_reading_stream_types = 0;
896
897 memcpy(tablebuf + tablepos, buf + 4 + adapt_len + 1, pointer_len - 1);
898
899 unsigned int pos = 0;
900 set_buf(tablebuf + pos, tablepos - pos, 0);
901
902 unsigned char section_id = get_bits(8);
903 get_bits(4);
904 unsigned int section_length = get_bits(12);
905 unsigned int program_number = get_bits(16);
906 get_bits(2);
907 unsigned char version_number = get_bits(5);
908 get_bits(1);
909 unsigned char section_number = get_bits(8);
910 unsigned char last_section_number = get_bits(8);
911 get_bits(3);
912 unsigned int PCR_PID = get_bits(13);
913 get_bits(4);
914 unsigned int program_info_length = get_bits(12);
915 int i=0;
916 unsigned char *descriptor_buf = (unsigned char *) malloc(program_info_length);
917 for (i = 0; i < program_info_length; i++)
918 {
919 descriptor_buf[i] = get_bits(8);
920 }
921
922 int cur_pos = 9 /* data so far */ + program_info_length;
923 done_reading_stream_types = 0;
924 while (!done_reading_stream_types)
925 {
926 unsigned char stream_type = get_bits(8);
927 get_bits(3);
928 unsigned int elementary_PID = get_bits(13);
929 get_bits(4);
930 unsigned int ES_info_length = get_bits(12);
931
932 int i=0;
933 unsigned char *ES_info_buf = (unsigned char *) malloc(ES_info_length);
934 for (i=0; i < ES_info_length; i++)
935 {
936 ES_info_buf[i] = get_bits(8);
937 }
938
939 if (stream_type == 0x02)
940 {
941 if (stream->ts_number_video_pids <= kMaxNumberVideoPIDS)
942 stream->ts_number_video_pids++;
943 stream->ts_video_pids[stream->ts_number_video_pids-1] = elementary_PID;
944 }
945 if ((stream_type == 0x04) || (stream_type == 0x81) || (stream_type == 0x03) || (stream_type == 0x06)) // ATSC Defines stream type 0x81 for AC-3/A52 audio, there's also some evidence of streams using type 6 for AC-3 audio too
946 {
947 if (stream->ts_number_audio_pids <= kMaxNumberAudioPIDS)
948 stream->ts_number_audio_pids++;
949 stream->ts_audio_pids[stream->ts_number_audio_pids-1] = elementary_PID;
950
951 stream->a52_info[stream->ts_number_audio_pids-1].lang_code = 'e' << 8 | 'n';
952 stream->ts_audio_stream_type[stream->ts_number_audio_pids-1] = stream_type;
953
954 if (ES_info_length > 0)
955 {
956 hb_log("decode_program_map - Elementary Stream Info Present, decode language codes ?");
957 }
958
959 }
960
961 cur_pos += 5 /* stream header */ + ES_info_length;
962
963 free(ES_info_buf);
964
965 if (cur_pos >= section_length - 4 /* stop before the CRC */)
966 done_reading_stream_types = 1;
967 }
968
969 free(descriptor_buf);
970 }
971
972 return 1;
973 }
974
975 int decode_PAT(unsigned char *buf, unsigned int *program_num, unsigned int *network_PID, unsigned int *program_map_PID)
976 {
977 // int maxchannels = 8;
978 // static ATSC_CHANNEL_INFO* channels;
979 //
980 // if (channels == NULL)
981 // channels = (ATSC_CHANNEL_INFO*) malloc(maxchannels * sizeof(ATSC_CHANNEL_INFO));
982 //
983 // int numchannels;
984
985 unsigned char tablebuf[1024];
986 unsigned int tablepos = 0;
987
988 int reading = 0;
989
990
991 // Get adaption header info
992 int adapt_len = 0;
993 int adaption = (buf[3] & 0x30) >> 4;
994 if (adaption == 0)
995 return 0;
996 else if (adaption == 0x2)
997 adapt_len = 184;
998 else if (adaption == 0x3)
999 adapt_len = buf[4] + 1;
1000 if (adapt_len > 184)
1001 return 0;
1002
1003 // Get pointer length
1004 int pointer_len = buf[4 + adapt_len] + 1;
1005
1006 // Get payload start indicator
1007 int start;
1008 start = (buf[1] & 0x40) != 0;
1009
1010 if (start)
1011 reading = 1;
1012
1013 // Add the payload for this packet to the current buffer
1014 if (reading && (184 - adapt_len) > 0)
1015 {
1016 if (tablepos + 184 - adapt_len - pointer_len > 1024)
1017 {
1018 hb_log("decode_PAT - Bad program section length (> 1024)");
1019 return 0;
1020 }
1021 memcpy(tablebuf + tablepos, buf + 4 + adapt_len + pointer_len, 184 - adapt_len - pointer_len);
1022 tablepos += 184 - adapt_len - pointer_len;
1023 }
1024
1025 if (start && reading)
1026 {
1027 memcpy(tablebuf + tablepos, buf + 4 + adapt_len + 1, pointer_len - 1);
1028
1029 unsigned int pos = 0;
1030 //while (pos < tablepos)
1031 {
1032 set_buf(tablebuf + pos, tablepos - pos, 0);
1033
1034 unsigned char section_id = get_bits(8);
1035 get_bits(4);
1036 unsigned int section_len = get_bits(12);
1037 unsigned int transport_id = get_bits(16);
1038 get_bits(2);
1039 unsigned int version_num = get_bits(5);
1040 unsigned int current_next = get_bits(1);
1041 unsigned int section_num = get_bits(8);
1042 unsigned int last_section = get_bits(8);
1043 // unsigned int protocol_ver = get_bits(8);
1044
1045 switch (section_id)
1046 {
1047 case 0x00:
1048 {
1049 // Program Association Section
1050 section_len -= 5; // Already read transport stream ID, version num, section num, and last section num
1051 section_len -= 4; // Ignore the CRC
1052 int curr_pos = 0;
1053 while (curr_pos < section_len)
1054 {
1055 unsigned int pkt_program_num = get_bits(16);
1056 if (program_num)
1057 *program_num = pkt_program_num;
1058
1059 get_bits(3); // Reserved
1060 if (pkt_program_num == 0)
1061 {
1062 unsigned int pkt_network_PID = get_bits(13);
1063 // printf("PAT - Transport ID = 0x%x (%d) program_num 0x%x (%d) network_PID = 0x%x (%d)\n", transport_id, transport_id, pkt_program_num, pkt_program_num, pkt_network_PID, pkt_network_PID);
1064 if (network_PID)
1065 *network_PID = pkt_network_PID;
1066
1067 }
1068 else
1069 {
1070 unsigned int pkt_program_map_PID = get_bits(13);
1071 // printf("PAT - Transport ID = 0x%x (%d) program_num 0x%x (%d) program_map_PID = 0x%x (%d)\n", transport_id, transport_id, pkt_program_num, pkt_program_num, pkt_program_map_PID, pkt_program_map_PID);
1072 if (program_map_PID)
1073 *program_map_PID = pkt_program_map_PID;
1074 }
1075 curr_pos += 4;
1076 }
1077 }
1078 break;
1079 case 0xC7:
1080 {
1081 break;
1082 }
1083 case 0xC8:
1084 {
1085 break;
1086 }
1087 }
1088
1089 pos += 3 + section_len;
1090 }
1091
1092 tablepos = 0;
1093 }
1094 return 1;
1095 }
1096
1097 static int flushbuf(hb_stream_t *stream)
1098 {
1099 int old_write_index = stream->ps_current_write_buffer_index;
1100
1101 if (stream->debug_output)
1102 {
1103 fwrite(stream->ps_decode_buffer[stream->ps_current_write_buffer_index].data, stream->ps_decode_buffer[stream->ps_current_write_buffer_index].len, 1, stream->debug_output);
1104 }
1105
1106 // Flip the buffers and start moving on to the next
1107 stream->ps_current_write_buffer_index++;
1108 if (stream->ps_current_write_buffer_index > kNumDecodeBuffers-1)
1109 stream->ps_current_write_buffer_index = 0;
1110
1111 if ( (stream->ps_decode_buffer[stream->ps_current_write_buffer_index].len != 0) || (stream->ps_decode_buffer[stream->ps_current_write_buffer_index].write_pos != 0) )
1112 {
1113 hb_log("flushbuf - new buffer (index %d) has non zero length and write position !", stream->ps_current_write_buffer_index);
1114 return 0;
1115 }
1116
1117 stream->ps_current_read_buffer_index = old_write_index;
1118 stream->ps_decode_buffer[stream->ps_current_read_buffer_index].read_pos = 0;
1119
1120 return 1;
1121 }
1122
1123 static int fwrite64(void* buf, int elsize, int elnum, hb_stream_t* stream)
1124 {
1125 int size = elsize;
1126 if (elnum > 1)
1127 size *= elnum;
1128
1129 int written = 0;
1130 int current_write_index = stream->ps_current_write_buffer_index;
1131
1132 if (size <= stream->ps_decode_buffer[current_write_index].size - stream->ps_decode_buffer[current_write_index].write_pos)
1133 {
1134 memcpy(stream->ps_decode_buffer[current_write_index].data + stream->ps_decode_buffer[current_write_index].write_pos, buf, size);
1135 stream->ps_decode_buffer[current_write_index].write_pos += size;
1136 stream->ps_decode_buffer[current_write_index].len = stream->ps_decode_buffer[current_write_index].write_pos;
1137 written = size;
1138 }
1139 else
1140 {
1141 memcpy(stream->ps_decode_buffer[current_write_index].data + stream->ps_decode_buffer[current_write_index].write_pos, buf, stream->ps_decode_buffer[current_write_index].size - stream->ps_decode_buffer[current_write_index].write_pos);
1142 written += stream->ps_decode_buffer[current_write_index].size - stream->ps_decode_buffer[current_write_index].write_pos;
1143 stream->ps_decode_buffer[current_write_index].write_pos += stream->ps_decode_buffer[current_write_index].size - stream->ps_decode_buffer[current_write_index].write_pos;
1144 stream->ps_decode_buffer[current_write_index].len = stream->ps_decode_buffer[current_write_index].write_pos;
1145
1146 if (flushbuf(stream))
1147 {
1148 // FLushing the buffer will have change the current write buffer
1149 current_write_index = stream->ps_current_write_buffer_index;
1150
1151 memcpy(stream->ps_decode_buffer[current_write_index].data, (unsigned char*)buf + written, size - written);
1152 stream->ps_decode_buffer[current_write_index].write_pos += size - written;
1153 stream->ps_decode_buffer[current_write_index].len = stream->ps_decode_buffer[current_write_index].write_pos;
1154 written += size - written;
1155 }
1156 }
1157
1158
1159 if (elnum == 1 && written == size)
1160 return 1;
1161 else
1162 return written / elsize;
1163 }
1164
1165 static int write_pack(hb_stream_t* stream, int64_t time)
1166 {
1167 unsigned char buf[64];
1168 set_buf(buf, 64, 1); // clear buffer
1169
1170 int64_t ext_time = time % 300;
1171 time = time / 300;
1172
1173 set_bits(0x000001ba, 32); // pack id 32
1174 set_bits(1, 2); // 0x01 2
1175 set_bits((unsigned int)(time >> 30), 3); // system_clock_reference_base 3
1176 set_bits(1, 1); // marker_bit 1
1177 set_bits((unsigned int)(time >> 15), 15); // system_clock_reference_base 15
1178 set_bits(1, 1); // marker_bit 1
1179 set_bits((unsigned int)time, 15); // system_clock_reference_base1 15
1180 set_bits(1, 1); // marker_bit 1
1181 set_bits((unsigned int)ext_time, 9); // system_clock_reference_extension 9
1182 set_bits(1, 1); // marker_bit 1
1183 set_bits(DEMUX, 22); // program_mux_rate 22
1184 set_bits(1, 1); // marker_bit 1
1185 set_bits(1, 1); // marker_bit 1
1186 set_bits(31, 5); // reserved 5
1187 set_bits(0, 3); // pack_stuffing_length 3
1188
1189 return fwrite64(buf, buf_size(), 1, stream) == 1;
1190 }
1191
1192 static int pad_buffer(hb_stream_t *stream, int pad)
1193 {
1194 pad -= 6;
1195
1196 char buf[6];
1197 buf[0] = '\x0'; buf[1] = '\x0'; buf[2] = '\x1'; buf[3] = '\xbe';
1198 buf[4] = pad >> 8; buf[5] = pad & 0xff;
1199
1200 if (fwrite64(buf, 6, 1, stream) != 1)
1201 return 0;
1202
1203 unsigned char padbyte = 0xff;
1204 int i=0;
1205 for (i = 0; i < pad; i++)
1206 {
1207 if (fwrite64(&padbyte, 1, 1, stream) != 1)
1208 return 0;
1209 }
1210
1211 return 1;
1212 }
1213
1214 int make_pes_header(unsigned char* buf, int streamid, int len, int64_t PTS, int64_t DTS)
1215 {
1216 int hdrlen = 0;
1217 int PTS_DTS_flags = 0;
1218 if (PTS != -1)
1219 {
1220 if (DTS != -1)
1221 {
1222 PTS_DTS_flags = 3;
1223 hdrlen += 10;
1224 }
1225 else
1226 {
1227 PTS_DTS_flags = 2;
1228 hdrlen += 5;
1229 }
1230 }
1231
1232 set_buf(buf, 9 + hdrlen, 1); // clear the buffer
1233
1234 set_bits(0x000001, 24); // packet_start_code_prefix 24
1235 set_bits((unsigned int)streamid, 8); // directory_stream_id 8
1236 set_bits(len, 16); // PES_packet_length 16
1237 set_bits(0x2, 2); // '10' 2
1238 set_bits(0, 2); // PES_scrambling_control 2
1239 set_bits(1, 1); // PES_priority 1
1240 set_bits(0, 1); // data_alignment_indicator 1
1241 set_bits(0, 1); // copyright 1
1242 set_bits(0, 1); // original_or_copy 1
1243 set_bits(PTS_DTS_flags, 2); // PTS_DTS_flags 2
1244 set_bits(0, 1); // ESCR_flag 1
1245 set_bits(0, 1); // ES_rate_flag 1
1246 set_bits(0, 1); // DSM_trick_mode_flag 1
1247 set_bits(0, 1); // additional_copy_info_flag 1
1248 set_bits(0, 1); // PES_CRC_flag 1
1249 set_bits(0, 1); // PES_extension_flag 1
1250 set_bits(hdrlen, 8); // PES_header_data_length 8
1251
1252 if (PTS_DTS_flags == 2)
1253 {
1254 set_bits(2, 4); // '0010' 4
1255 set_bits((unsigned int)(PTS >> 30), 3); // PTS [32..30] 3
1256 set_bits(1, 1); // marker bit 1
1257 set_bits((unsigned int)(PTS >> 15), 15); // PTS [29..15] 15
1258 set_bits(1, 1); // marker bit 1
1259 set_bits((unsigned int)PTS, 15); // PTS [14..0] 15
1260 set_bits(1, 1); // marker bit 1
1261 }
1262 else if (PTS_DTS_flags == 3)
1263 {
1264 set_bits(3, 4); // '0011' 4
1265 set_bits((unsigned int)(PTS >> 30), 3); // PTS [32..30] 3
1266 set_bits(1, 1); // marker bit 1
1267 set_bits((unsigned int)(PTS >> 15), 15); // PTS [29..15] 15
1268 set_bits(1, 1); // marker bit 1
1269 set_bits((unsigned int)PTS, 15); // PTS [14..0] 15
1270 set_bits(1, 1); // marker bit 1
1271 set_bits(1, 4); // '0001' 4
1272 set_bits((unsigned int)(DTS >> 30), 3); // DTS [32..30] 3
1273 set_bits(1, 1); // marker bit 1
1274 set_bits((unsigned int)(DTS >> 15), 15); // DTS [29..15] 15
1275 set_bits(1, 1); // marker bit 1
1276 set_bits((unsigned int)DTS, 15); // DTS [14..0] 15
1277 set_bits(1, 1); // marker bit 1
1278 }
1279
1280 return buf_size();
1281 }
1282
1283 int generate_output_data(hb_stream_t *stream, int write_ac3, int curstream, int pid)
1284 {
1285 unsigned char ac3_substream_id[4];
1286 int ac3len = 0;
1287
1288 if (write_ac3)
1289 {
1290 // Make a four byte ac3 streamid
1291 ac3_substream_id[0] = 0x80; // Four byte AC3 CODE??
1292 ac3_substream_id[1] = 0x01;
1293 ac3_substream_id[2] = 0x00; // WHY??? OH WHY??
1294 ac3_substream_id[3] = 0x02;
1295 ac3len = 4;
1296 }
1297
1298 int written = 0; // Bytes we've written to output file
1299 int pos = 0; // Position in PES packet buffer
1300
1301 for (;;)
1302 {
1303 // int64_t fpos = ftell64(fout);
1304 if ((stream->ps_decode_buffer[stream->ps_current_write_buffer_index].len % HB_DVD_READ_BUFFER_SIZE) != 0)
1305 {
1306 hb_log("write_output_stream - Packet's not falling on read buffer size boundries!");
1307 return 1;
1308 }
1309
1310 // Get total length of this pack
1311 int len = min(14 + ac3len + stream->ts_packetpos[curstream] - pos, HB_DVD_READ_BUFFER_SIZE);
1312
1313 // Figure out stuffing (if we have less than 16 bytes left)
1314 int stuffing = 0;
1315 if (len < HB_DVD_READ_BUFFER_SIZE && HB_DVD_READ_BUFFER_SIZE - len < 16)
1316 {
1317 stuffing = HB_DVD_READ_BUFFER_SIZE - len;
1318 len += stuffing;
1319 }
1320
1321 // Write out pack header
1322 off_t file_offset = ftello(stream->file_handle);
1323 int64_t packet_time = (file_offset * CLOCKRATE / STREAMRATE) + 0 /*file_time*/;
1324 if (!write_pack(stream, packet_time))
1325 {
1326 hb_log("write_output_stream - Couldn't write pack header!");
1327 return 1;
1328 }
1329
1330 // if (pid == stream->ts_audio_pids[0])
1331 // stream->ts_packetbuf[curstream][pos + 3] = stream->ts_streamid[kAudioStream];
1332 // else
1333 // stream->ts_packetbuf[curstream][pos + 3] = stream->ts_streamid[kVideoStream];
1334 int index_of_selected_pid = -1;
1335 if ((index_of_selected_pid = index_of_video_pid(pid,stream)) < 0)
1336 {
1337 if ((index_of_selected_pid = index_of_audio_pid(pid,stream)) < 0)
1338 {
1339 hb_log("generate_output_data - cannot find pid 0x%x (%d) in selected audio or video pids", pid, pid);
1340 return 0;
1341 }
1342 else
1343 {
1344 stream->ts_packetbuf[curstream][pos + 3] = stream->ts_streamid[stream->ts_number_video_pids + index_of_selected_pid];
1345 }
1346 }
1347 else
1348 stream->ts_packetbuf[curstream][pos + 3] = stream->ts_streamid[index_of_selected_pid];
1349
1350 // Packet length..
1351 // Subtract pack size (14) and pes id and len (6) from lenth
1352 stream->ts_packetbuf[curstream][pos + 4] = (len - 6 - 14) >> 8; stream->ts_packetbuf[curstream][pos + 5] = (len - 6 - 14) & 0xFF;
1353
1354 // Add any stuffing bytes to header extra len
1355 int hdrsize = 9 + stream->ts_packetbuf[curstream][pos + 8];
1356 stream->ts_packetbuf[curstream][pos + 8] += stuffing; // Add stuffing to header bytes
1357
1358 // Write out id, streamid, len
1359 if (fwrite64(stream->ts_packetbuf[curstream] + pos, hdrsize, 1, stream) != 1) // Write pes id, streamid, and len
1360 {
1361 hb_log("write_output_stream - Failed to write output file!");
1362 return 1;
1363 }
1364
1365 // Write stuffing
1366 int i=0;
1367 for (i = 0; i < stuffing; i++) // Write any stuffing bytes
1368 {
1369 unsigned char stuff = 0xff;
1370 if (fwrite64(&stuff, 1, 1, stream) != 1)
1371 {
1372 hb_log("write_output_stream - Failed to write output file!");
1373 return 1;
1374 }
1375 }
1376
1377 // Write ac3 streamid
1378 if (ac3len != 0)
1379 {
1380 if (fwrite64(ac3_substream_id, ac3len, 1, stream) != 1)
1381 {
1382 hb_log("write_output_stream - Failed to write output file!");
1383 return 1;
1384 }
1385 }
1386
1387 // Write rest of data len minus headersize (9) stuffing, and pack size (14)
1388 if (fwrite64(stream->ts_packetbuf[curstream] + pos + hdrsize, len - hdrsize - 14 - stuffing - ac3len, 1, stream) != 1) // Write data bytes
1389 {
1390 hb_log("write_output_stream - Failed to write output file!");
1391 return 1;
1392 }
1393 written += len;
1394
1395 // Add len minus stuff we added like the pack (14) and the stuffing.
1396 pos += len - 14 - stuffing - ac3len;
1397 if (pos == stream->ts_packetpos[curstream])
1398 break;
1399
1400 // Add pes header for next packet
1401 pos -= 9;
1402 // make_pes_header(stream->ts_packetbuf[curstream] + pos, (pid == stream->ts_video_pids[0] ? stream->ts_streamid[kVideoStream] : stream->ts_streamid[kAudioStream]), 0, -1, -1);
1403 make_pes_header(stream->ts_packetbuf[curstream] + pos, stream->ts_streamid[curstream], 0, -1, -1);
1404 }
1405
1406 // Write padding
1407 if ((written % HB_DVD_READ_BUFFER_SIZE) != 0)
1408 {
1409 int left = HB_DVD_READ_BUFFER_SIZE - (written % HB_DVD_READ_BUFFER_SIZE);
1410
1411 // Pad out to HB_DVD_READ_BUFFER_SIZE bytes
1412 if (!pad_buffer(stream, left))
1413 {
1414 hb_log("write_output_stream - Couldn't write pad buffer!");
1415 return 1;
1416 }
1417 }
1418
1419 stream->ts_packetpos[curstream] = 0;
1420 stream->ts_streamcont[curstream] = -1;
1421
1422 return 0;
1423 }
1424
1425 static void hb_ts_handle_mpeg_audio(hb_stream_t *stream, int curstream, unsigned char* buf, int adapt_len )
1426 {
1427 // Although we don't have AC3/A52 audio here we can still use the same structure to record this useful information.
1428
1429 stream->a52_info[curstream - stream->ts_number_video_pids].flags = A52_STEREO;
1430 stream->a52_info[curstream - stream->ts_number_video_pids].rate = 48000 /*Hz*/;
1431 stream->a52_info[curstream - stream->ts_number_video_pids].bitrate = 384000 /*Bps*/;
1432 }
1433
1434 static int hb_ts_handle_ac3_audio(hb_stream_t *stream, int curstream, unsigned char* buf, int adapt_len )
1435 {
1436 int spos, dpos;
1437
1438 // Make sure we start with 0x0b77
1439 if (stream->ts_packetbuf[curstream][9 + stream->ts_packetbuf[curstream][8]] != 0x0b || stream->ts_packetbuf[curstream][9 + stream->ts_packetbuf[curstream][8] + 1] != 0x77)
1440 {
1441 spos = 9 + stream->ts_packetbuf[curstream][8];
1442 dpos = 9 + stream->ts_packetbuf[curstream][8];
1443 while (spos <= stream->ts_packetpos[curstream] - 2 && !(stream->ts_packetbuf[curstream][spos] == 0x0b && stream->ts_packetbuf[curstream][spos + 1] == 0x77))
1444 spos++;
1445
1446 if (!(stream->ts_packetbuf[curstream][spos] == 0x0b && stream->ts_packetbuf[curstream][spos + 1] == 0x77))
1447 {
1448 hb_log("hb_ts_stream_decode - Couldn't sync AC3 packet!");
1449 stream->ts_skipbad[curstream] = 1;
1450 return 0;
1451 }
1452
1453 while (spos < stream->ts_packetpos[curstream])
1454 {
1455 stream->ts_packetbuf[curstream][dpos] = stream->ts_packetbuf[curstream][spos];
1456 spos++;
1457 dpos++;
1458 }
1459 stream->ts_packetpos[curstream] = dpos;
1460 }
1461
1462 // Check the next packet to make sure IT starts with a 0x0b77
1463 int plen = 0;
1464 // if (buf[4 + adapt_len] == 0 && buf[4 + adapt_len + 1] == 0 && // Starting with an mpeg header?
1465 // buf[4 + adapt_len + 2] == 1 && buf[4 + adapt_len + 3] == 0xBD)
1466 plen = 9 + buf[4 + adapt_len + 8];
1467 int pstart = 4 + adapt_len + plen;
1468 if (buf[pstart] != 0x0b || buf[pstart + 1] != 0x77)
1469 {
1470 spos = pstart;
1471 while (spos < 188 - 2 && !(buf[spos] == 0x0b && buf[spos + 1] == 0x77))
1472 {
1473 stream->ts_packetbuf[curstream][stream->ts_packetpos[curstream]] = buf[spos];
1474 stream->ts_packetpos[curstream]++;
1475 spos++;
1476 }
1477
1478 if (!(buf[spos] == 0x0b && buf[spos + 1] == 0x77))
1479 {
1480 hb_log("hb_ts_stream_decode - Couldn't sync AC3 packet!");
1481 stream->ts_skipbad[curstream] = 1;
1482 return 0;
1483 }
1484
1485 adapt_len = spos - 4 - plen;
1486
1487 dpos = spos - 1;
1488 spos = pstart - 1;
1489 while (spos >= pstart - plen)
1490 {
1491 buf[dpos] = buf[spos];
1492 spos--;
1493 dpos--;
1494 }
1495 }
1496
1497 int flags, rate, bitrate;
1498 if( a52_syncinfo( &buf[pstart], &flags, &rate, &bitrate ) )
1499 {
1500 stream->a52_info[curstream - stream->ts_number_video_pids].flags = flags;
1501 stream->a52_info[curstream - stream->ts_number_video_pids].rate = rate;
1502 stream->a52_info[curstream - stream->ts_number_video_pids].bitrate = bitrate;
1503 }
1504 return 1;
1505 }
1506
1507 static void hb_ts_stream_find_pids(hb_stream_t *stream)
1508 {
1509 unsigned char buf[188];
1510 int curstream = 0;
1511
1512 // Stream ID info
1513 unsigned int program_num = 0;
1514 unsigned int network_PID = 0;
1515 unsigned int program_map_PID = 0;
1516
1517 // align to first packet
1518 align_to_next_packet(stream->file_handle);
1519
1520 // Read the Transport Stream Packets (188 bytes each) looking at first for PID 0 (the PAT PID), then decode that
1521 // to find the program map PID and then decode that to get the list of audio and video PIDs
1522
1523 int bytesReadInPacket = 0;
1524 for (;;)
1525 {
1526 // Try to read packet..
1527 int bytesRead;
1528 if ((bytesRead = fread(buf+bytesReadInPacket, 1, 188-bytesReadInPacket, stream->file_handle)) != 188-bytesReadInPacket)
1529 {
1530 if (bytesRead < 0)
1531 bytesRead = 0;
1532 bytesReadInPacket += bytesRead;
1533
1534 hb_log("hb_ts_stream_find_pids - end of file");
1535 break;
1536 }
1537 else
1538 {
1539 // curfilepos += bytesRead;
1540 bytesReadInPacket = 0;
1541 }
1542
1543 // Check sync byte
1544 if ((buf[0] != 0x47) && (buf[0] != 0x72) && (buf[0] != 0x29))
1545 {
1546 // __int64 pos = ftell64(fin);
1547 hb_log("hb_ts_stream_find_pids - Bad transport packet (no sync byte 0x47)!");
1548 int i = 0;
1549 for (i=0; i < stream->ts_number_video_pids + stream->ts_number_audio_pids; i++)
1550 stream->ts_skipbad[i] = 1;
1551 // stream->ts_skipbad[kAudioStream] = stream->ts_skipbad[kVideoStream] = 1;
1552 continue;
1553 }
1554
1555 // Get pid
1556 int pid = (((buf[1] & 0x1F) << 8) | buf[2]) & 0x1FFF;
1557
1558 if ((pid == 0x0000) && (program_num == 0))
1559 {
1560 decode_PAT(buf, &program_num, &network_PID, &program_map_PID);
1561 continue;
1562 }
1563
1564 if (pid == 0x1ffb)
1565 {
1566 printf("Need to decode PSIP data !\n");
1567 continue;
1568 }
1569
1570 if ((network_PID > 0) && (pid == network_PID))
1571 {
1572 printf("Need to Decode network PID section !\n");
1573 continue;
1574 }
1575
1576 if ((program_map_PID > 0) && (pid == program_map_PID))
1577 {
1578 decode_program_map(buf, stream);
1579 break;;
1580 }
1581
1582 // Skip until we have a complete set of PIDs
1583 if ((stream->ts_number_video_pids == 0) || (stream->ts_number_audio_pids == 0))
1584 continue;
1585 }
1586
1587 hb_log("hb_ts_stream_find_pids - found the following PIDS");
1588 hb_log(" Video PIDS : ");
1589 int i=0;
1590 for (i=0; i < stream->ts_number_video_pids; i++)
1591 {
1592 hb_log(" 0x%x (%d)", stream->ts_video_pids[i], stream->ts_video_pids[i]);
1593 }
1594 hb_log(" Audio PIDS : ");
1595 for (i = 0; i < stream->ts_number_audio_pids; i++)
1596 {
1597 hb_log(" 0x%x (%d)", stream->ts_audio_pids[i], stream->ts_audio_pids[i]);
1598 }
1599 }
1600
1601 int index_of_video_pid(int pid, hb_stream_t *stream)
1602 {
1603 int found_pid = -1, i = 0;
1604
1605 for (i = 0; (i < stream->ts_number_video_pids) && (found_pid < 0); i++)
1606 {
1607 if (pid == stream->ts_video_pids[i])
1608 found_pid = i;
1609 }
1610 return found_pid;
1611 }
1612
1613 int index_of_audio_pid(int pid, hb_stream_t *stream)
1614 {
1615 int i = 0, found_pid = -1;
1616
1617 // If a selected audio pid index has been set it indicates
1618 // which of the potential pids we need to output so only return
1619 // that index for the appropriate pid. Other pids should just
1620 // be ignored.
1621 if (stream->ts_selected_audio_pid_index >= 0)
1622 {
1623 if (pid == stream->ts_audio_pids[stream->ts_selected_audio_pid_index])
1624 return stream->ts_selected_audio_pid_index;
1625 else
1626 return -1;
1627 }
1628
1629 // If no specific pid index is set then we're probably just gathering
1630 // pid and/or stream information (during DecodePreviews for example)
1631 // so return the appropriate index
1632 for (i = 0; (i < stream->ts_number_audio_pids) && (found_pid < 0); i++)
1633 {
1634 if (pid == stream->ts_audio_pids[i])
1635 found_pid = i;
1636 }
1637 return found_pid;
1638 }
1639
1640 int index_of_pid(int pid, hb_stream_t *stream)
1641 {
1642 int found_pid = -1;
1643
1644 if ((found_pid = index_of_video_pid(pid, stream)) >= 0)
1645 return found_pid;
1646
1647 if ((found_pid = index_of_audio_pid(pid, stream)) >= 0)
1648 return found_pid;
1649
1650 return found_pid;
1651 }
1652
1653 /***********************************************************************
1654 * hb_ts_stream_decode
1655 ***********************************************************************
1656 *
1657 **********************************************************************/
1658 static void hb_ts_stream_decode(hb_stream_t *stream)
1659 {
1660 unsigned char buf[188];
1661 int curstream;
1662 int doing_iframe;
1663
1664 int i = 0;
1665 for (i=0; i < stream->ts_number_video_pids + stream->ts_number_audio_pids; i++)
1666 {
1667 // stream->ts_skipbad[kAudioStream] = stream->ts_skipbad[kVideoStream] = 0;
1668 stream->ts_skipbad[i] = 0;
1669 }
1670
1671 doing_iframe = 0;
1672
1673 if ((stream->ts_number_video_pids == 0) || (stream->ts_number_audio_pids == 0))
1674 {
1675 hb_log("hb_ts_stream_decode - no Video or Audio PID selected, cannot decode transport stream");
1676 return;
1677 }
1678
1679 int bytesReadInPacket = 0;
1680 int curr_write_buffer_index = stream->ps_current_write_buffer_index;
1681
1682 // Write output data until a buffer switch occurs.
1683 while (curr_write_buffer_index == stream->ps_current_write_buffer_index)
1684 {
1685 // Try to read packet..
1686 int bytesRead;
1687 if ((bytesRead = fread(buf+bytesReadInPacket, 1, 188-bytesReadInPacket, stream->file_handle)) != 188-bytesReadInPacket)
1688 {
1689 if (bytesRead < 0)
1690 bytesRead = 0;
1691 bytesReadInPacket += bytesRead;
1692
1693 // Flush any outstanding output data - we're done here.
1694 flushbuf(stream);
1695 break;
1696 }
1697 else
1698 {
1699 // curfilepos += bytesRead;
1700 bytesReadInPacket = 0;
1701 }
1702
1703 // Check sync byte
1704 if ((buf[0] != 0x47) && (buf[0] != 0x72) && (buf[0] != 0x29))
1705 {
1706 // __int64 pos = ftell64(fin);
1707 hb_log("hb_ts_stream_decode - Bad transport packet (no sync byte 0x47)!");
1708 for (i=0; i < stream->ts_number_video_pids + stream->ts_number_audio_pids; i++)
1709 {
1710 // stream->ts_skipbad[kAudioStream] = stream->ts_skipbad[kVideoStream] = 1;
1711 stream->ts_skipbad[i] = 1;
1712 }
1713 continue;
1714 }
1715
1716 // Get pid
1717 int pid = (((buf[1] & 0x1F) << 8) | buf[2]) & 0x1FFF;
1718
1719 // Skip this block
1720 if (index_of_pid(pid, stream) < 0)
1721 continue;
1722 // if (pid != stream->ts_audio_pids[0] && pid != stream->ts_video_pids[0])
1723 // continue;
1724
1725 // Get the pos and buf - we organize our streams as 'n' video streams then 'm' audio streams
1726 int index_of_selected_pid = -1;
1727 if ((index_of_selected_pid = index_of_video_pid(pid,stream)) < 0)
1728 {
1729 // Not a video PID perhaps audio ?
1730 if ((index_of_selected_pid = index_of_audio_pid(pid,stream)) < 0)
1731 {
1732 hb_log("hb_ts_stream_decode - Unknown pid 0x%x (%d)", pid, pid);
1733 continue;
1734 }
1735 else
1736 {
1737 curstream = stream->ts_number_video_pids + index_of_selected_pid;
1738 if (curstream > kMaxNumberDecodeStreams)
1739 {
1740 hb_log("hb_ts_stream_decode - Too many streams %d", curstream);
1741 continue;
1742 }
1743 }
1744 }
1745 else
1746 curstream = index_of_selected_pid;
1747
1748 // if (pid == stream->ts_video_pids[0])
1749 // curstream = 0;
1750 // else
1751 // curstream = 1;
1752
1753 // Get start code
1754 int start;
1755 start = (buf[1] & 0x40) != 0;
1756
1757 if (!start && stream->ts_skipbad[curstream])
1758 continue;
1759
1760 // Get error
1761 int errorbit = (buf[1] & 0x80) != 0;
1762 if (errorbit)
1763 {
1764 hb_log("hb_ts_stream_decode - Error bit set in packet");
1765 stream->ts_skipbad[curstream] = 1;
1766 continue;
1767 }
1768
1769 // Get adaption header info
1770 int adaption = (buf[3] & 0x30) >> 4;
1771 int adapt_len = 0;
1772
1773 // Get continuity
1774 int continuity = (buf[3] & 0xF);
1775 if ((stream->ts_streamcont[curstream] != -1) && (adaption & 0x01 == 0x01)) // Continuity only increments for adaption values of 0x3 or 0x01
1776 {
1777 if (continuity != ((stream->ts_streamcont[curstream] + 1) & 0xF))
1778 {
1779 hb_log("hb_ts_stream_decode - Bad continuity code in packet");
1780 stream->ts_skipbad[curstream] = 1;
1781 continue;
1782 }
1783 stream->ts_streamcont[curstream] = continuity;
1784 }
1785
1786 // Get adaption header size
1787 if (adaption == 0)
1788 {
1789 hb_log("hb_ts_stream_decode - Bad adaption code (code was 0)!");
1790 for (i=0; i < stream->ts_number_video_pids + stream->ts_number_audio_pids; i++)
1791 {
1792 stream->ts_skipbad[i] = 1;
1793 }
1794 // stream->ts_skipbad[kAudioStream] = stream->ts_skipbad[kVideoStream] = 1;
1795 continue;
1796 }
1797 else if (adaption == 0x2)
1798 adapt_len = 184;
1799 else if (adaption == 0x3)
1800 {
1801 adapt_len = buf[4] + 1;
1802 if (adapt_len > 184)
1803 {
1804 hb_log("hb_ts_stream_decode - Invalid adapt len (was > 183)!");
1805 for (i=0; i < stream->ts_number_video_pids + stream->ts_number_audio_pids; i++)
1806 {
1807 stream->ts_skipbad[i] = 1;
1808 }
1809 // stream->ts_skipbad[kAudioStream] = stream->ts_skipbad[kVideoStream] = 1;
1810 }
1811 }
1812
1813 // HBO is slick, it doesn't bother to sync AC3 packets with PES elementary stream packets.. so
1814 // we have to swizzle them together! (ARGHH!)
1815 // if (pid == stream->ts_audio_pids[0] && start)
1816 if ((index_of_audio_pid(pid, stream) >= 0) && start)
1817 {
1818 // Is there an AC3 packet start 0b77 code in this packet??
1819 int sync_found = 0;
1820 unsigned char *p = buf + 4 + adapt_len;
1821 while (p <= buf + 186)
1822 {
1823 if (p[0] == 0x0b && p[1] == 0x77)
1824 {
1825 sync_found = 1;
1826 break;
1827 }
1828 p++;
1829 }
1830
1831 // Couldn't find an AC3 sync start in this packet.. don't make a PES packet!
1832 if (!sync_found)
1833 {
1834 // int pos = ftell(fin);
1835 // error("AC3 packet sync not found in start frame");
1836 // return 1;
1837 adapt_len += 9 + buf[4 + adapt_len + 8];
1838 start = 0;
1839 }
1840 }
1841
1842 // Get PCR
1843 if (start && (adaption & 0x2) && (buf[5] & 0x10))
1844 {
1845 int64_t PCR_base = ((int64_t)buf[6] << 25) | ((int64_t)buf[7] << 17) |
1846 ((int64_t)buf[8] << 9) | ((int64_t)buf[9] << 1) | ((int64_t)buf[10] >> 7);
1847 int64_t PCR_ext = ((int64_t)(buf[10] & 0x1) << 8) | ((int64_t)buf[11]);
1848 int64_t PCR = PCR_base * 300 + PCR_ext;
1849 }
1850
1851 // Get random
1852 // bool random = false;
1853 // if (start && (adaption & 0x2))
1854 // random = (buf[5] & 0x40) != 0; // BUG: SOME TS STREAMS DON'T HAVE THE RANDOM BIT (ABC!! ALIAS)
1855
1856 // Found a random access point (now we can start a frame/audio packet..)
1857 if (start)
1858 {
1859 // Check to see if this is an i_frame (group of picture start)
1860 if (pid == stream->ts_video_pids[0])
1861 {
1862 // printf("Found Video Start for pid 0x%x\n", pid);
1863 // Look for the Group of Pictures packet.. indicates this is an I-Frame packet..
1864 doing_iframe = 0;
1865 unsigned int strid = 0;
1866 int i = 4;
1867 for (i = 4 + adapt_len; i < 188; i++)
1868 {
1869 strid = (strid << 8) | buf[i];
1870 if (strid == 0x000001B8) // group_start_code
1871 {
1872 // found a Group of Pictures header, subsequent picture must be an I-frame
1873 doing_iframe = 1;
1874 }
1875 else if (strid == 0x000001B3) // sequence_header code
1876 {
1877 doing_iframe = 1;
1878 }
1879 else if (strid == 0x00000100) // picture_start_code
1880 {
1881 // picture_header, let's see if it's an I-frame
1882 if (i<187)
1883 {
1884 // int pic_start_code = (buf[i+2] >> 3) & 0x07;
1885 // hb_log("hb_ts_stream_decode - picture_start_code header value = 0x%x (%d)", pic_start_code, pic_start_code);
1886 // check if picture_coding_type == 1
1887 if ((buf[i+2] & (0x7 << 3)) == (1 << 3))
1888 {
1889 // found an I-frame picture
1890 doing_iframe = 1;
1891 }
1892 }
1893 }
1894
1895 if (doing_iframe)
1896 {
1897 if (!stream->ts_foundfirst[curstream])
1898 {
1899 stream->ts_foundfirst[curstream] = 1;
1900 // first_video_PCR = PCR;
1901 }
1902 break;
1903 }
1904 }
1905 }
1906 else if (index_of_audio_pid(pid, stream) >= 0)
1907 {
1908 if (stream->ts_foundfirst[0]) // Set audio found first ONLY after first video frame found. There's an assumption here that stream '0' is a video stream
1909 {
1910 stream->ts_foundfirst[curstream] |= 1;
1911 }
1912 }
1913
1914 // If we were skipping a bad packet, start fresh on this new PES packet..
1915 if (stream->ts_skipbad[curstream] == 1)
1916 {
1917 stream->ts_skipbad[curstream] = 0;
1918 stream->ts_packetpos[curstream] = 0;
1919 }
1920
1921 // Get the continuity code of this packet
1922 stream->ts_streamcont[curstream] = continuity;
1923 }
1924
1925 // Write a 2048 byte program stream packet..
1926 if (start && stream->ts_packetpos[curstream] > 0 && stream->ts_foundfirst[curstream] && !stream->ts_skipbad[curstream])
1927 {
1928 // Save the substream id block so we can added it to subsequent blocks
1929 int write_ac3 = 0;
1930 // if (pid == stream->ts_audio_pids[0] /*&& audstreamid == 0xBD*/)
1931 if (index_of_audio_pid(pid, stream) >= 0)
1932 {
1933 if ((stream->ts_audio_stream_type[curstream] == 0x04) || (stream->ts_audio_stream_type[curstream] == 0x81))
1934 {
1935 write_ac3 = hb_ts_handle_ac3_audio(stream, curstream, buf, adapt_len);
1936 }
1937 else if (stream->ts_audio_stream_type[curstream] == 0x03)
1938 {
1939 hb_ts_handle_mpeg_audio(stream, curstream, buf, adapt_len);
1940 }
1941 else
1942 {
1943 hb_log("hb_ts_stream_decode - Unknown Audio Stream type ! 0x%x (%d)", stream->ts_audio_stream_type[curstream], stream->ts_audio_stream_type[curstream]);
1944 }
1945 }
1946
1947 if (generate_output_data(stream, write_ac3, curstream, pid) != 0)
1948 return ;
1949 }
1950
1951 // Add the payload for this packet to the current buffer
1952 if (stream->ts_foundfirst[curstream] && (184 - adapt_len) > 0)
1953 {
1954 memcpy(stream->ts_packetbuf[curstream] + stream->ts_packetpos[curstream], buf + 4 + adapt_len, 184 - adapt_len);
1955 stream->ts_packetpos[curstream] += 184 - adapt_len;
1956 }
1957 }
1958 }
1959
1960 /***********************************************************************
1961 * hb_ts_stream_reset
1962 ***********************************************************************
1963 *
1964 **********************************************************************/
1965 static void hb_ts_stream_reset(hb_stream_t *stream)
1966 {
1967 int i=0;
1968 for (i=0; i < kNumDecodeBuffers; i++)
1969 {
1970 stream->ps_decode_buffer[i].read_pos = 0;
1971 stream->ps_decode_buffer[i].write_pos = 0;
1972 stream->ps_decode_buffer[i].len = 0;
1973 }
1974
1975 for (i=0; i < kMaxNumberDecodeStreams; i++)
1976 {
1977 stream->ts_streamcont[i] = -1;
1978 }
1979
1980 stream->ps_current_write_buffer_index = 0;
1981 stream->ps_current_read_buffer_index = 1;
1982
1983 align_to_next_packet(stream->file_handle);
1984 }
1985
GIT mirror of HandBrake SVN. Along with unofficial development branches.