xref: /haiku/src/kits/media/MediaTrack.cpp (revision 21258e2674226d6aa732321b6f8494841895af5f) 
1 /*
2  * Copyright 2002-2007, Marcus Overhagen <marcus@overhagen.de>
3  * Copyright 2009-2010, Stephan Aßmus <superstippi@gmx.de>
4  * Copyright 2013, Haiku, Inc. All Rights Reserved.
5  * All rights reserved. Distributed under the terms of the MIT license.
6  *
7  * Authors:
8  *		Stephan Aßmus, superstippi@gmx.de
9  *		Marcus Overhagen, marcus@overhagen.de
10  */
11 
12 
13 #include <MediaTrack.h>
14 
15 #include <new>
16 
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <string.h>
20 
21 #include <Roster.h>
22 
23 #include "MediaExtractor.h"
24 #include "MediaWriter.h"
25 #include "PluginManager.h"
26 
27 
28 //#define TRACE_MEDIA_TRACK
29 #ifdef TRACE_MEDIA_TRACK
30 #	ifndef TRACE
31 #		define TRACE printf
32 #	endif
33 #else
34 #	ifndef TRACE
35 #		define TRACE(a...)
36 #	endif
37 #endif
38 
39 #define ERROR(a...) fprintf(stderr, a)
40 
41 
42 #define CONVERT_TO_INT32 0
43 	// TODO: Test! This triggers a few bugs!
44 
45 // flags used for workarounds
46 enum {
47 	FORCE_RAW_AUDIO 				= 0x0001,
48 	FORCE_RAW_VIDEO 				= 0x0002,
49 	FORCE_RAW_AUDIO_INT16_FORMAT 	= 0x0010,
50 	FORCE_RAW_AUDIO_INT32_FORMAT 	= 0x0020,
51 	FORCE_RAW_AUDIO_FLOAT_FORMAT 	= 0x0040,
52 	FORCE_RAW_AUDIO_HOST_ENDIAN 	= 0x0100,
53 	IGNORE_ENCODED_AUDIO 			= 0x1000,
54 	IGNORE_ENCODED_VIDEO 			= 0x2000,
55 };
56 
57 #define B_MEDIA_DISABLE_FORMAT_TRANSLATION 0x4000
58 	// TODO: move this (after name change?) to MediaDefs.h
59 
60 
61 class RawDecoderChunkProvider : public ChunkProvider {
62 public:
63 							RawDecoderChunkProvider(Decoder* decoder,
64 								int buffer_size, int frame_size);
65 	virtual					~RawDecoderChunkProvider();
66 
67 			status_t		GetNextChunk(const void** chunkBuffer,
68 								size_t* chunkSize,
69 								media_header* mediaHeader);
70 
71 private:
72 			Decoder*		fDecoder;
73 			void*			fBuffer;
74 			int				fBufferSize;
75 			int				fFrameSize;
76 };
77 
78 
79 /*************************************************************
80  * protected BMediaTrack
81  *************************************************************/
82 
83 BMediaTrack::~BMediaTrack()
84 {
85 	CALLED();
86 
87 	gPluginManager.DestroyDecoder(fRawDecoder);
88 	gPluginManager.DestroyDecoder(fDecoder);
89 	gPluginManager.DestroyEncoder(fEncoder);
90 }
91 
92 /*************************************************************
93  * public BMediaTrack
94  *************************************************************/
95 
96 status_t
97 BMediaTrack::InitCheck() const
98 {
99 	CALLED();
100 
101 	return fInitStatus;
102 }
103 
104 
105 status_t
106 BMediaTrack::GetCodecInfo(media_codec_info* _codecInfo) const
107 {
108 	CALLED();
109 
110 	if (fDecoder == NULL)
111 		return B_NO_INIT;
112 
113 	*_codecInfo = fCodecInfo;
114 	strlcpy(_codecInfo->pretty_name, fCodecInfo.pretty_name,
115 		sizeof(_codecInfo->pretty_name));
116 
117 	return B_OK;
118 }
119 
120 
121 status_t
122 BMediaTrack::EncodedFormat(media_format* _format) const
123 {
124 	CALLED();
125 
126 	if (_format == NULL)
127 		return B_BAD_VALUE;
128 
129 	if (fExtractor == NULL)
130 		return B_NO_INIT;
131 
132 	*_format = *fExtractor->EncodedFormat(fStream);
133 
134 #ifdef TRACE_MEDIA_TRACK
135 	char s[200];
136 	string_for_format(*_format, s, sizeof(s));
137 	printf("BMediaTrack::EncodedFormat: %s\n", s);
138 #endif
139 
140 	return B_OK;
141 }
142 
143 
144 // for BeOS R5 compatibility
145 extern "C" status_t DecodedFormat__11BMediaTrackP12media_format(
146 	BMediaTrack* self, media_format* _format);
147 
148 status_t DecodedFormat__11BMediaTrackP12media_format(BMediaTrack* self,
149 	media_format* _format)
150 {
151 	return self->DecodedFormat(_format, 0);
152 }
153 
154 
155 status_t
156 BMediaTrack::DecodedFormat(media_format* _format, uint32 flags)
157 {
158 	CALLED();
159 
160 	if (_format == NULL)
161 		return B_BAD_VALUE;
162 
163 	if (fExtractor == NULL || fDecoder == NULL)
164 		return B_NO_INIT;
165 
166 	gPluginManager.DestroyDecoder(fRawDecoder);
167 	fRawDecoder = NULL;
168 
169 #ifdef TRACE_MEDIA_TRACK
170 	char s[200];
171 	string_for_format(*_format, s, sizeof(s));
172 	printf("BMediaTrack::DecodedFormat: req1: %s\n", s);
173 #endif
174 
175 	if ((fWorkaroundFlags & FORCE_RAW_AUDIO)
176 		|| ((fWorkaroundFlags & IGNORE_ENCODED_AUDIO)
177 			&& _format->type == B_MEDIA_ENCODED_AUDIO)) {
178 		_format->type = B_MEDIA_RAW_AUDIO;
179 		_format->u.raw_audio = media_multi_audio_format::wildcard;
180 	}
181 	if ((fWorkaroundFlags & FORCE_RAW_VIDEO)
182 		|| ((fWorkaroundFlags & IGNORE_ENCODED_VIDEO)
183 			&& _format->type == B_MEDIA_ENCODED_VIDEO)) {
184 		_format->type = B_MEDIA_RAW_VIDEO;
185 		_format->u.raw_video = media_raw_video_format::wildcard;
186 	}
187 	if (_format->type == B_MEDIA_RAW_AUDIO) {
188 		if (fWorkaroundFlags & FORCE_RAW_AUDIO_HOST_ENDIAN)
189 			_format->u.raw_audio.byte_order = B_MEDIA_HOST_ENDIAN;
190 
191 		if (fWorkaroundFlags & FORCE_RAW_AUDIO_INT16_FORMAT) {
192 			_format->u.raw_audio.format
193 				= media_raw_audio_format::B_AUDIO_SHORT;
194 		}
195 		if (fWorkaroundFlags & FORCE_RAW_AUDIO_INT32_FORMAT) {
196 			_format->u.raw_audio.format
197 				= media_raw_audio_format::B_AUDIO_INT;
198 		}
199 		if (fWorkaroundFlags & FORCE_RAW_AUDIO_FLOAT_FORMAT) {
200 			_format->u.raw_audio.format
201 				= media_raw_audio_format::B_AUDIO_FLOAT;
202 		}
203 	}
204 
205 #ifdef TRACE_MEDIA_TRACK
206 	string_for_format(*_format, s, sizeof(s));
207 	printf("BMediaTrack::DecodedFormat: req2: %s\n", s);
208 #endif
209 
210 	fFormat = *_format;
211 	status_t result = fDecoder->NegotiateOutputFormat(_format);
212 
213 #ifdef TRACE_MEDIA_TRACK
214 	string_for_format(*_format, s, sizeof(s));
215 	printf("BMediaTrack::DecodedFormat: nego: %s\n", s);
216 #endif
217 
218 	if (_format->type == 0) {
219 #ifdef TRACE_MEDIA_TRACK
220 		printf("BMediaTrack::DecodedFormat: Decoder didn't set output format "
221 			"type.\n");
222 #endif
223 	}
224 
225 	if (_format->type == B_MEDIA_RAW_AUDIO) {
226 		if (_format->u.raw_audio.byte_order == 0) {
227 #ifdef TRACE_MEDIA_TRACK
228 			printf("BMediaTrack::DecodedFormat: Decoder didn't set raw audio "
229 				"output byte order.\n");
230 #endif
231 		}
232 		if (_format->u.raw_audio.format == 0) {
233 #ifdef TRACE_MEDIA_TRACK
234 			printf("BMediaTrack::DecodedFormat: Decoder didn't set raw audio "
235 				"output sample format.\n");
236 #endif
237 		}
238 		if (_format->u.raw_audio.buffer_size <= 0) {
239 #ifdef TRACE_MEDIA_TRACK
240 			printf("BMediaTrack::DecodedFormat: Decoder didn't set raw audio "
241 				"output buffer size.\n");
242 #endif
243 		}
244 	}
245 
246 	if (_format->type == B_MEDIA_RAW_VIDEO) {
247 		if (_format->u.raw_video.display.format == 0) {
248 #ifdef TRACE_MEDIA_TRACK
249 			printf("BMediaTrack::DecodedFormat: Decoder didn't set raw video "
250 				"output color space.\n");
251 #endif
252 		}
253 		if (_format->u.raw_video.display.line_width == 0) {
254 #ifdef TRACE_MEDIA_TRACK
255 			printf("BMediaTrack::DecodedFormat: Decoder didn't set raw video "
256 				"output line_width.\n");
257 #endif
258 		}
259 		if (_format->u.raw_video.display.line_count == 0) {
260 #ifdef TRACE_MEDIA_TRACK
261 			printf("BMediaTrack::DecodedFormat: Decoder didn't set raw video "
262 				"output line_count.\n");
263 #endif
264 		}
265 		if (_format->u.raw_video.display.bytes_per_row == 0) {
266 #ifdef TRACE_MEDIA_TRACK
267 			printf("BMediaTrack::DecodedFormat: Decoder didn't set raw video "
268 				"output bytes_per_row.\n");
269 #endif
270 		}
271 	}
272 
273 	if ((flags & B_MEDIA_DISABLE_FORMAT_TRANSLATION) == 0) {
274 		if (fFormat.type == B_MEDIA_RAW_AUDIO
275 			&& _format->type == B_MEDIA_RAW_AUDIO
276 			&& fFormat.u.raw_audio.format != 0
277 			&& fFormat.u.raw_audio.format != _format->u.raw_audio.format) {
278 			if (SetupFormatTranslation(*_format, &fFormat))
279 				*_format = fFormat;
280 		}
281 	}
282 
283 	fFormat = *_format;
284 
285 //	string_for_format(*_format, s, sizeof(s));
286 //	printf("BMediaTrack::DecodedFormat: status: %s\n", s);
287 	return result;
288 }
289 
290 
291 status_t
292 BMediaTrack::GetMetaData(BMessage* _data) const
293 {
294 	CALLED();
295 
296 	if (fExtractor == NULL)
297 		return B_NO_INIT;
298 
299 	if (_data == NULL)
300 		return B_BAD_VALUE;
301 
302 	_data->MakeEmpty();
303 
304 	return fExtractor->GetStreamMetaData(fStream, _data);
305 }
306 
307 
308 int64
309 BMediaTrack::CountFrames() const
310 {
311 	CALLED();
312 
313 	int64 frames = fExtractor ? fExtractor->CountFrames(fStream) : 0;
314 //	printf("BMediaTrack::CountFrames: %lld\n", frames);
315 	return frames;
316 }
317 
318 
319 bigtime_t
320 BMediaTrack::Duration() const
321 {
322 	CALLED();
323 
324 	bigtime_t duration = fExtractor ? fExtractor->Duration(fStream) : 0;
325 //	printf("BMediaTrack::Duration: %lld\n", duration);
326 	return duration;
327 }
328 
329 
330 int64
331 BMediaTrack::CurrentFrame() const
332 {
333 	return fCurrentFrame;
334 }
335 
336 
337 bigtime_t
338 BMediaTrack::CurrentTime() const
339 {
340 	return fCurrentTime;
341 }
342 
343 // BMediaTrack::ReadFrames(char*, long long*, media_header*)
344 // Compatibility for R5 and below. Required by Corum III and Civ:CTP.
345 #if __GNUC__ < 3
346 
347 extern "C" status_t
348 ReadFrames__11BMediaTrackPcPxP12media_header(BMediaTrack* self,
349 	char* _buffer, int64* _frameCount, media_header* header)
350 {
351 	return self->ReadFrames(_buffer, _frameCount, header, 0);
352 }
353 
354 #endif	// __GNUC__ < 3
355 
356 status_t
357 BMediaTrack::ReadFrames(void* buffer, int64* _frameCount, media_header* header)
358 {
359 	return ReadFrames(buffer, _frameCount, header, NULL);
360 }
361 
362 
363 status_t
364 BMediaTrack::ReadFrames(void* buffer, int64* _frameCount,
365 	media_header* _header, media_decode_info* info)
366 {
367 //	CALLED();
368 
369 	if (fDecoder == NULL)
370 		return B_NO_INIT;
371 
372 	if (buffer == NULL || _frameCount == NULL)
373 		return B_BAD_VALUE;
374 
375 	media_header header;
376 	if (_header == NULL)
377 		_header = &header;
378 
379 	// Always clear the header first, as the decoder may not set all fields.
380 	memset(_header, 0, sizeof(media_header));
381 
382 	status_t result = fRawDecoder != NULL
383 		? fRawDecoder->Decode(buffer, _frameCount, _header, info)
384 		: fDecoder->Decode(buffer, _frameCount, _header, info);
385 
386 	if (result == B_OK) {
387 		fCurrentFrame += *_frameCount;
388 		bigtime_t framesDuration = (bigtime_t)(*_frameCount * 1000000
389 			/ _FrameRate());
390 		fCurrentTime = _header->start_time + framesDuration;
391 #if 0
392 	// This debug output shows drift between calculated fCurrentFrame and
393 	// time-based current frame, if there is any.
394 	if (fFormat.type == B_MEDIA_RAW_AUDIO) {
395 		printf("current frame: %lld / calculated: %lld (%.2f/%.2f)\r",
396 			fCurrentFrame,
397 			int64(fCurrentTime * _FrameRate() / 1000000.0 + 0.5),
398 			fCurrentTime / 1000000.0, (float)fCurrentFrame / _FrameRate());
399 		fflush(stdout);
400 	}
401 #endif
402 	} else {
403 		ERROR("BMediaTrack::ReadFrames: decoder returned error %#" B_PRIx32
404 			" (%s)\n", result, strerror(result));
405 		*_frameCount = 0;
406 	}
407 
408 #if 0
409 	PRINT(1, "BMediaTrack::ReadFrames: stream %ld, start-time %5Ld.%06Ld, "
410 		"%lld frames\n", fStream,  _header->start_time / 1000000,
411 		_header->start_time % 1000000, *out_frameCount);
412 #endif
413 
414 	return result;
415 }
416 
417 
418 status_t
419 BMediaTrack::ReplaceFrames(const void* inBuffer, int64* _frameCount,
420 	const media_header* header)
421 {
422 	UNIMPLEMENTED();
423 
424 	// TODO: Actually, a file is either open for reading or writing at the
425 	// moment. Since the chunk size of encoded media data will change,
426 	// implementing this call will only be possible for raw media tracks.
427 
428 	return B_NOT_SUPPORTED;
429 }
430 
431 
432 status_t
433 BMediaTrack::SeekToTime(bigtime_t* _time, int32 flags)
434 {
435 	CALLED();
436 
437 	if (fDecoder == NULL || fExtractor == NULL)
438 		return B_NO_INIT;
439 
440 	if (_time == NULL)
441 		return B_BAD_VALUE;
442 
443 	// Make sure flags are valid
444 	flags = (flags & B_MEDIA_SEEK_DIRECTION_MASK) | B_MEDIA_SEEK_TO_TIME;
445 
446 	#if DEBUG
447 	bigtime_t requestedTime = *_time;
448 	#endif
449 	int64 frame = 0;
450 
451 	status_t result = fExtractor->Seek(fStream, flags, &frame, _time);
452 	if (result != B_OK) {
453 		ERROR("BMediaTrack::SeekToTime: extractor seek failed\n");
454 		return result;
455 	}
456 
457 	result = fDecoder->SeekedTo(frame, *_time);
458 	if (result != B_OK) {
459 		ERROR("BMediaTrack::SeekToTime: decoder seek failed\n");
460 		return result;
461 	}
462 
463 	if (fRawDecoder != NULL) {
464 		result = fRawDecoder->SeekedTo(frame, *_time);
465 		if (result != B_OK) {
466 			ERROR("BMediaTrack::SeekToTime: raw decoder seek failed\n");
467 			return result;
468 		}
469 	}
470 
471 	fCurrentFrame = frame;
472 	fCurrentTime = *_time;
473 
474 	PRINT(1, "BMediaTrack::SeekToTime finished, requested %.6f, result %.6f\n",
475 		requestedTime / 1000000.0, *_time / 1000000.0);
476 
477 	return B_OK;
478 }
479 
480 
481 status_t
482 BMediaTrack::SeekToFrame(int64* _frame, int32 flags)
483 {
484 	CALLED();
485 
486 	if (fDecoder == NULL || fExtractor == NULL)
487 		return B_NO_INIT;
488 
489 	if (_frame == NULL)
490 		return B_BAD_VALUE;
491 
492 	// Make sure flags are valid
493 	flags = (flags & B_MEDIA_SEEK_DIRECTION_MASK) | B_MEDIA_SEEK_TO_FRAME;
494 
495 	#if DEBUG
496 	int64 requestedFrame = *_frame;
497 	#endif
498 	bigtime_t time = 0;
499 
500 	status_t result = fExtractor->Seek(fStream, flags, _frame, &time);
501 	if (result != B_OK) {
502 		ERROR("BMediaTrack::SeekToFrame: extractor seek failed\n");
503 		return result;
504 	}
505 
506 	result = fDecoder->SeekedTo(*_frame, time);
507 	if (result != B_OK) {
508 		ERROR("BMediaTrack::SeekToFrame: decoder seek failed\n");
509 		return result;
510 	}
511 
512 	if (fRawDecoder != NULL) {
513 		result = fRawDecoder->SeekedTo(*_frame, time);
514 		if (result != B_OK) {
515 			ERROR("BMediaTrack::SeekToFrame: raw decoder seek failed\n");
516 			return result;
517 		}
518 	}
519 
520 	fCurrentFrame = *_frame;
521 	fCurrentTime = time;
522 
523 	PRINT(1, "BMediaTrack::SeekToTime SeekToFrame, requested %lld, "
524 		"result %lld\n", requestedFrame, *_frame);
525 
526 	return B_OK;
527 }
528 
529 
530 status_t
531 BMediaTrack::FindKeyFrameForTime(bigtime_t* _time, int32 flags) const
532 {
533 	CALLED();
534 
535 	if (fExtractor == NULL)
536 		return B_NO_INIT;
537 
538 	if (_time == NULL)
539 		return B_BAD_VALUE;
540 
541 	// Make sure flags are valid
542 	flags = (flags & B_MEDIA_SEEK_DIRECTION_MASK) | B_MEDIA_SEEK_TO_TIME;
543 
544 	int64 frame = 0;
545 		// dummy frame, will be ignored because of flags
546 	status_t result = fExtractor->FindKeyFrame(fStream, flags, &frame, _time);
547 	if (result != B_OK) {
548 		ERROR("BMediaTrack::FindKeyFrameForTime: extractor seek failed: %s\n",
549 			strerror(result));
550 	}
551 
552 	return result;
553 }
554 
555 
556 status_t
557 BMediaTrack::FindKeyFrameForFrame(int64* _frame, int32 flags) const
558 {
559 	CALLED();
560 
561 	if (fExtractor == NULL)
562 		return B_NO_INIT;
563 
564 	if (_frame == NULL)
565 		return B_BAD_VALUE;
566 
567 	// Make sure flags are valid
568 	flags = (flags & B_MEDIA_SEEK_DIRECTION_MASK) | B_MEDIA_SEEK_TO_FRAME;
569 
570 	bigtime_t time = 0;
571 		// dummy time, will be ignored because of flags
572 	status_t result = fExtractor->FindKeyFrame(fStream, flags, _frame, &time);
573 	if (result != B_OK) {
574 		ERROR("BMediaTrack::FindKeyFrameForFrame: extractor seek failed: %s\n",
575 			strerror(result));
576 	}
577 
578 	return result;
579 }
580 
581 
582 status_t
583 BMediaTrack::ReadChunk(char** _buffer, int32* _size, media_header* _header)
584 {
585 	CALLED();
586 
587 	if (fExtractor == NULL)
588 		return B_NO_INIT;
589 
590 	if (_buffer == NULL || _size == NULL)
591 		return B_BAD_VALUE;
592 
593 	media_header header;
594 	if (_header == NULL)
595 		_header = &header;
596 
597 	// Always clear the header first, as the extractor may not set all fields.
598 	memset(_header, 0, sizeof(media_header));
599 
600 	const void* buffer;
601 	size_t size;
602 	status_t result = fExtractor->GetNextChunk(fStream, &buffer, &size,
603 		_header);
604 
605 	if (result == B_OK) {
606 		*_buffer = const_cast<char*>(static_cast<const char*>(buffer));
607 			// TODO: Change the pointer type when we break the API.
608 		*_size = size;
609 		// TODO: This changes the meaning of fCurrentTime from pointing
610 		// to the next chunk start time (i.e. after seeking) to the start time
611 		// of the last chunk. Asking the extractor for the current time will
612 		// not work so well because of the chunk cache. But providing a
613 		// "duration" field in the media_header could be useful.
614 		fCurrentTime = _header->start_time;
615 		fCurrentFrame = (int64)(fCurrentTime * _FrameRate() / 1000000LL);
616 
617 	}
618 
619 	return result;
620 }
621 
622 
623 status_t
624 BMediaTrack::AddCopyright(const char* copyright)
625 {
626 	if (fWriter == NULL)
627 		return B_NO_INIT;
628 
629 	return fWriter->SetCopyright(fStream, copyright);
630 }
631 
632 
633 status_t
634 BMediaTrack::AddTrackInfo(uint32 code, const void* data, size_t size,
635 	uint32 flags)
636 {
637 	if (fWriter == NULL)
638 		return B_NO_INIT;
639 
640 	return fWriter->AddTrackInfo(fStream, code, data, size, flags);
641 }
642 
643 
644 status_t
645 BMediaTrack::WriteFrames(const void* data, int32 frameCount, int32 flags)
646 {
647 	media_encode_info encodeInfo;
648 	encodeInfo.flags = flags;
649 
650 	return WriteFrames(data, frameCount, &encodeInfo);
651 }
652 
653 
654 status_t
655 BMediaTrack::WriteFrames(const void* data, int64 frameCount,
656 	media_encode_info* info)
657 {
658 	if (fEncoder == NULL)
659 		return B_NO_INIT;
660 
661 	return fEncoder->Encode(data, frameCount, info);
662 }
663 
664 
665 status_t
666 BMediaTrack::WriteChunk(const void* data, size_t size, uint32 flags)
667 {
668 	media_encode_info encodeInfo;
669 	encodeInfo.flags = flags;
670 
671 	return WriteChunk(data, size, &encodeInfo);
672 }
673 
674 
675 status_t
676 BMediaTrack::WriteChunk(const void* data, size_t size, media_encode_info* info)
677 {
678 	if (fWriter == NULL)
679 		return B_NO_INIT;
680 
681 	return fWriter->WriteChunk(fStream, data, size, info);
682 }
683 
684 
685 status_t
686 BMediaTrack::Flush()
687 {
688 	if (fWriter == NULL)
689 		return B_NO_INIT;
690 
691 	return fWriter->Flush();
692 }
693 
694 
695 // deprecated BeOS R5 API
696 BParameterWeb*
697 BMediaTrack::Web()
698 {
699 	BParameterWeb* web;
700 	if (GetParameterWeb(&web) == B_OK)
701 		return web;
702 
703 	return NULL;
704 }
705 
706 
707 status_t
708 BMediaTrack::GetParameterWeb(BParameterWeb** outWeb)
709 {
710 	if (outWeb == NULL)
711 		return B_BAD_VALUE;
712 
713 	if (fEncoder == NULL)
714 		return B_NO_INIT;
715 
716 	// TODO: This method is new in Haiku. The header mentions it returns a
717 	// copy. But how could it even do that? How can one clone a web and make
718 	// it point to the same BControllable?
719 	*outWeb = fEncoder->ParameterWeb();
720 	if (*outWeb != NULL)
721 		return B_OK;
722 
723 	return B_NOT_SUPPORTED;
724 }
725 
726 
727 status_t
728 BMediaTrack::GetParameterValue(int32 id, void* value, size_t* size)
729 {
730 	if (value == NULL || size == NULL)
731 		return B_BAD_VALUE;
732 
733 	if (fEncoder == NULL)
734 		return B_NO_INIT;
735 
736 	return fEncoder->GetParameterValue(id, value, size);
737 }
738 
739 
740 status_t
741 BMediaTrack::SetParameterValue(int32 id, const void* value, size_t size)
742 {
743 	if (value == NULL || size == 0)
744 		return B_BAD_VALUE;
745 
746 	if (fEncoder == NULL)
747 		return B_NO_INIT;
748 
749 	return fEncoder->SetParameterValue(id, value, size);
750 }
751 
752 
753 BView*
754 BMediaTrack::GetParameterView()
755 {
756 	if (fEncoder == NULL)
757 		return NULL;
758 
759 	return fEncoder->ParameterView();
760 }
761 
762 
763 status_t
764 BMediaTrack::GetQuality(float* quality)
765 {
766 	if (quality == NULL)
767 		return B_BAD_VALUE;
768 
769 	encode_parameters parameters;
770 	status_t result = GetEncodeParameters(&parameters);
771 	if (result != B_OK)
772 		return result;
773 
774 	*quality = parameters.quality;
775 
776 	return B_OK;
777 }
778 
779 
780 status_t
781 BMediaTrack::SetQuality(float quality)
782 {
783 	encode_parameters parameters;
784 	status_t result = GetEncodeParameters(&parameters);
785 	if (result != B_OK)
786 		return result;
787 
788 	if (quality < 0.0f)
789 		quality = 0.0f;
790 
791 	if (quality > 1.0f)
792 		quality = 1.0f;
793 
794 	parameters.quality = quality;
795 
796 	return SetEncodeParameters(&parameters);
797 }
798 
799 
800 status_t
801 BMediaTrack::GetEncodeParameters(encode_parameters* parameters) const
802 {
803 	if (parameters == NULL)
804 		return B_BAD_VALUE;
805 
806 	if (fEncoder == NULL)
807 		return B_NO_INIT;
808 
809 	return fEncoder->GetEncodeParameters(parameters);
810 }
811 
812 
813 status_t
814 BMediaTrack::SetEncodeParameters(encode_parameters* parameters)
815 {
816 	if (parameters == NULL)
817 		return B_BAD_VALUE;
818 
819 	if (fEncoder == NULL)
820 		return B_NO_INIT;
821 
822 	return fEncoder->SetEncodeParameters(parameters);
823 }
824 
825 
826 status_t
827 BMediaTrack::Perform(int32 selector, void* data)
828 {
829 	return B_OK;
830 }
831 
832 // #pragma mark - private
833 
834 
835 BMediaTrack::BMediaTrack(BPrivate::media::MediaExtractor* extractor,
836 	int32 stream)
837 {
838 	CALLED();
839 
840 	fWorkaroundFlags = 0;
841 	fDecoder = NULL;
842 	fRawDecoder = NULL;
843 	fExtractor = extractor;
844 	fStream = stream;
845 	fInitStatus = B_OK;
846 
847 	SetupWorkaround();
848 
849 	status_t ret = fExtractor->CreateDecoder(fStream, &fDecoder, &fCodecInfo);
850 	if (ret != B_OK) {
851 		TRACE("BMediaTrack::BMediaTrack: Error: creating decoder failed: "
852 			"%s\n", strerror(ret));
853 		// We do not set fInitStatus here, because ReadChunk should still work.
854 		fDecoder = NULL;
855 	}
856 
857 	fCurrentFrame = 0;
858 	fCurrentTime = 0;
859 
860 	// not used:
861 	fEncoder = NULL;
862 	fEncoderID = 0;
863 	fWriter = NULL;
864 }
865 
866 
867 BMediaTrack::BMediaTrack(BPrivate::media::MediaWriter* writer,
868 	int32 streamIndex, media_format* format,
869 	const media_codec_info* codecInfo)
870 {
871 	CALLED();
872 
873 	fWorkaroundFlags = 0;
874 	fEncoder = NULL;
875 	fEncoderID = -1;
876 		// TODO: Not yet sure what this was needed for...
877 	fWriter = writer;
878 	fStream = streamIndex;
879 	fInitStatus = B_OK;
880 
881 	SetupWorkaround();
882 
883 	if (codecInfo != NULL) {
884 		status_t ret = fWriter->CreateEncoder(&fEncoder, codecInfo, format);
885 		if (ret != B_OK) {
886 			TRACE("BMediaTrack::BMediaTrack: Error: creating decoder failed: "
887 				"%s\n", strerror(ret));
888 			// We do not set fInitStatus here, because WriteChunk should still
889 			// work.
890 			fEncoder = NULL;
891 		} else {
892 			fCodecInfo = *codecInfo;
893 			fInitStatus = fEncoder->SetUp(format);
894 		}
895 	}
896 
897 	fFormat = *format;
898 
899 	// not used:
900 	fCurrentFrame = 0;
901 	fCurrentTime = 0;
902 	fDecoder = NULL;
903 	fRawDecoder = NULL;
904 	fExtractor = NULL;
905 }
906 
907 
908 // Does nothing, returns B_ERROR, for Zeta compatiblity only
909 status_t
910 BMediaTrack::ControlCodec(int32 selector, void* io_data, size_t size)
911 {
912 	return B_ERROR;
913 }
914 
915 
916 void
917 BMediaTrack::SetupWorkaround()
918 {
919 	app_info	ainfo;
920 	thread_info	tinfo;
921 
922 	get_thread_info(find_thread(0), &tinfo);
923 	be_roster->GetRunningAppInfo(tinfo.team, &ainfo);
924 
925 	if (strcmp(ainfo.signature, "application/x-vnd.marcone-soundplay") == 0) {
926 		fWorkaroundFlags = FORCE_RAW_AUDIO | FORCE_RAW_AUDIO_INT16_FORMAT
927 			| FORCE_RAW_AUDIO_HOST_ENDIAN;
928 		printf("BMediaTrack::SetupWorkaround: SoundPlay workaround active\n");
929 	}
930 	if (strcmp(ainfo.signature, "application/x-vnd.Be.MediaPlayer") == 0) {
931 		fWorkaroundFlags = IGNORE_ENCODED_AUDIO | IGNORE_ENCODED_VIDEO;
932 		printf("BMediaTrack::SetupWorkaround: MediaPlayer workaround active\n");
933 	}
934 
935 #if CONVERT_TO_INT32
936 	// TODO: Test
937 	if (!(fWorkaroundFlags & FORCE_RAW_AUDIO_INT16_FORMAT))
938 		fWorkaroundFlags |= FORCE_RAW_AUDIO_INT32_FORMAT;
939 #endif
940 }
941 
942 
943 bool
944 BMediaTrack::SetupFormatTranslation(const media_format &from, media_format* to)
945 {
946 	gPluginManager.DestroyDecoder(fRawDecoder);
947 	fRawDecoder = NULL;
948 
949 #ifdef TRACE_MEDIA_TRACK
950 	char s[200];
951 	string_for_format(from, s, sizeof(s));
952 	printf("BMediaTrack::SetupFormatTranslation: from: %s\n", s);
953 #endif
954 
955 	status_t result = gPluginManager.CreateDecoder(&fRawDecoder, from);
956 	if (result != B_OK) {
957 		ERROR("BMediaTrack::SetupFormatTranslation: CreateDecoder failed\n");
958 		return false;
959 	}
960 
961 	// XXX video?
962 	int buffer_size = from.u.raw_audio.buffer_size;
963 	int frame_size = (from.u.raw_audio.format & 15)
964 		* from.u.raw_audio.channel_count;
965 	media_format fromNotConst = from;
966 
967 	ChunkProvider* chunkProvider
968 		= new (std::nothrow) RawDecoderChunkProvider(fDecoder, buffer_size,
969 			frame_size);
970 	if (chunkProvider == NULL) {
971 		ERROR("BMediaTrack::SetupFormatTranslation: can't create chunk "
972 			"provider\n");
973 		goto error;
974 	}
975 	fRawDecoder->SetChunkProvider(chunkProvider);
976 
977 	result = fRawDecoder->Setup(&fromNotConst, 0, 0);
978 	if (result != B_OK) {
979 		ERROR("BMediaTrack::SetupFormatTranslation: Setup failed\n");
980 		goto error;
981 	}
982 
983 #ifdef TRACE_MEDIA_TRACK
984 	string_for_format(*to, s, sizeof(s));
985 	printf("BMediaTrack::SetupFormatTranslation:   to: %s\n", s);
986 #endif
987 
988 	result = fRawDecoder->NegotiateOutputFormat(to);
989 	if (result != B_OK) {
990 		ERROR("BMediaTrack::SetupFormatTranslation: NegotiateOutputFormat "
991 			"failed\n");
992 		goto error;
993 	}
994 
995 #ifdef TRACE_MEDIA_TRACK
996 	string_for_format(*to, s, sizeof(s));
997 	printf("BMediaTrack::SetupFormatTranslation:  result: %s\n", s);
998 #endif
999 
1000 	return true;
1001 
1002 error:
1003 	gPluginManager.DestroyDecoder(fRawDecoder);
1004 	fRawDecoder = NULL;
1005 	return false;
1006 }
1007 
1008 
1009 double
1010 BMediaTrack::_FrameRate() const
1011 {
1012 	switch (fFormat.type) {
1013 		case B_MEDIA_RAW_VIDEO:
1014 			return fFormat.u.raw_video.field_rate;
1015 		case B_MEDIA_ENCODED_VIDEO:
1016 			return fFormat.u.encoded_video.output.field_rate;
1017 		case B_MEDIA_RAW_AUDIO:
1018 			return fFormat.u.raw_audio.frame_rate;
1019 		case B_MEDIA_ENCODED_AUDIO:
1020 			return fFormat.u.encoded_audio.output.frame_rate;
1021 		default:
1022 			return 1.0;
1023 	}
1024 }
1025 
1026 #if 0
1027 // unimplemented
1028 BMediaTrack::BMediaTrack()
1029 BMediaTrack::BMediaTrack(const BMediaTrack &)
1030 BMediaTrack &BMediaTrack::operator=(const BMediaTrack &)
1031 #endif
1032 
1033 status_t BMediaTrack::_Reserved_BMediaTrack_0(int32 arg, ...) { return B_ERROR; }
1034 status_t BMediaTrack::_Reserved_BMediaTrack_1(int32 arg, ...) { return B_ERROR; }
1035 status_t BMediaTrack::_Reserved_BMediaTrack_2(int32 arg, ...) { return B_ERROR; }
1036 status_t BMediaTrack::_Reserved_BMediaTrack_3(int32 arg, ...) { return B_ERROR; }
1037 status_t BMediaTrack::_Reserved_BMediaTrack_4(int32 arg, ...) { return B_ERROR; }
1038 status_t BMediaTrack::_Reserved_BMediaTrack_5(int32 arg, ...) { return B_ERROR; }
1039 status_t BMediaTrack::_Reserved_BMediaTrack_6(int32 arg, ...) { return B_ERROR; }
1040 status_t BMediaTrack::_Reserved_BMediaTrack_7(int32 arg, ...) { return B_ERROR; }
1041 status_t BMediaTrack::_Reserved_BMediaTrack_8(int32 arg, ...) { return B_ERROR; }
1042 status_t BMediaTrack::_Reserved_BMediaTrack_9(int32 arg, ...) { return B_ERROR; }
1043 status_t BMediaTrack::_Reserved_BMediaTrack_10(int32 arg, ...) { return B_ERROR; }
1044 status_t BMediaTrack::_Reserved_BMediaTrack_11(int32 arg, ...) { return B_ERROR; }
1045 status_t BMediaTrack::_Reserved_BMediaTrack_12(int32 arg, ...) { return B_ERROR; }
1046 status_t BMediaTrack::_Reserved_BMediaTrack_13(int32 arg, ...) { return B_ERROR; }
1047 status_t BMediaTrack::_Reserved_BMediaTrack_14(int32 arg, ...) { return B_ERROR; }
1048 status_t BMediaTrack::_Reserved_BMediaTrack_15(int32 arg, ...) { return B_ERROR; }
1049 status_t BMediaTrack::_Reserved_BMediaTrack_16(int32 arg, ...) { return B_ERROR; }
1050 status_t BMediaTrack::_Reserved_BMediaTrack_17(int32 arg, ...) { return B_ERROR; }
1051 status_t BMediaTrack::_Reserved_BMediaTrack_18(int32 arg, ...) { return B_ERROR; }
1052 status_t BMediaTrack::_Reserved_BMediaTrack_19(int32 arg, ...) { return B_ERROR; }
1053 status_t BMediaTrack::_Reserved_BMediaTrack_20(int32 arg, ...) { return B_ERROR; }
1054 status_t BMediaTrack::_Reserved_BMediaTrack_21(int32 arg, ...) { return B_ERROR; }
1055 status_t BMediaTrack::_Reserved_BMediaTrack_22(int32 arg, ...) { return B_ERROR; }
1056 status_t BMediaTrack::_Reserved_BMediaTrack_23(int32 arg, ...) { return B_ERROR; }
1057 status_t BMediaTrack::_Reserved_BMediaTrack_24(int32 arg, ...) { return B_ERROR; }
1058 status_t BMediaTrack::_Reserved_BMediaTrack_25(int32 arg, ...) { return B_ERROR; }
1059 status_t BMediaTrack::_Reserved_BMediaTrack_26(int32 arg, ...) { return B_ERROR; }
1060 status_t BMediaTrack::_Reserved_BMediaTrack_27(int32 arg, ...) { return B_ERROR; }
1061 status_t BMediaTrack::_Reserved_BMediaTrack_28(int32 arg, ...) { return B_ERROR; }
1062 status_t BMediaTrack::_Reserved_BMediaTrack_29(int32 arg, ...) { return B_ERROR; }
1063 status_t BMediaTrack::_Reserved_BMediaTrack_30(int32 arg, ...) { return B_ERROR; }
1064 status_t BMediaTrack::_Reserved_BMediaTrack_31(int32 arg, ...) { return B_ERROR; }
1065 status_t BMediaTrack::_Reserved_BMediaTrack_32(int32 arg, ...) { return B_ERROR; }
1066 status_t BMediaTrack::_Reserved_BMediaTrack_33(int32 arg, ...) { return B_ERROR; }
1067 status_t BMediaTrack::_Reserved_BMediaTrack_34(int32 arg, ...) { return B_ERROR; }
1068 status_t BMediaTrack::_Reserved_BMediaTrack_35(int32 arg, ...) { return B_ERROR; }
1069 status_t BMediaTrack::_Reserved_BMediaTrack_36(int32 arg, ...) { return B_ERROR; }
1070 status_t BMediaTrack::_Reserved_BMediaTrack_37(int32 arg, ...) { return B_ERROR; }
1071 status_t BMediaTrack::_Reserved_BMediaTrack_38(int32 arg, ...) { return B_ERROR; }
1072 status_t BMediaTrack::_Reserved_BMediaTrack_39(int32 arg, ...) { return B_ERROR; }
1073 status_t BMediaTrack::_Reserved_BMediaTrack_40(int32 arg, ...) { return B_ERROR; }
1074 status_t BMediaTrack::_Reserved_BMediaTrack_41(int32 arg, ...) { return B_ERROR; }
1075 status_t BMediaTrack::_Reserved_BMediaTrack_42(int32 arg, ...) { return B_ERROR; }
1076 status_t BMediaTrack::_Reserved_BMediaTrack_43(int32 arg, ...) { return B_ERROR; }
1077 status_t BMediaTrack::_Reserved_BMediaTrack_44(int32 arg, ...) { return B_ERROR; }
1078 status_t BMediaTrack::_Reserved_BMediaTrack_45(int32 arg, ...) { return B_ERROR; }
1079 status_t BMediaTrack::_Reserved_BMediaTrack_46(int32 arg, ...) { return B_ERROR; }
1080 status_t BMediaTrack::_Reserved_BMediaTrack_47(int32 arg, ...) { return B_ERROR; }
1081 
1082 
1083 RawDecoderChunkProvider::RawDecoderChunkProvider(Decoder* decoder,
1084 	int buffer_size, int frame_size)
1085 {
1086 //	printf("RawDecoderChunkProvider: buffer_size %d, frame_size %d\n",
1087 //		buffer_size, frame_size);
1088 	fDecoder = decoder;
1089 	fFrameSize = frame_size;
1090 	fBufferSize = buffer_size;
1091 	fBuffer = malloc(buffer_size);
1092 }
1093 
1094 
1095 RawDecoderChunkProvider::~RawDecoderChunkProvider()
1096 {
1097 	free(fBuffer);
1098 }
1099 
1100 
1101 status_t
1102 RawDecoderChunkProvider::GetNextChunk(const void** chunkBuffer,
1103 	size_t* chunkSize, media_header* header)
1104 {
1105 	int64 frames;
1106 	media_decode_info info;
1107 	status_t result = fDecoder->Decode(fBuffer, &frames, header, &info);
1108 	if (result == B_OK) {
1109 		*chunkBuffer = fBuffer;
1110 		*chunkSize = frames * fFrameSize;
1111 //		printf("RawDecoderChunkProvider::GetNextChunk, %lld frames, "
1112 //			"%ld bytes, start-time %lld\n", frames, *chunkSize,
1113 //			header->start_time);
1114 	} else
1115 		ERROR("RawDecoderChunkProvider::GetNextChunk failed\n");
1116 
1117 	return result;
1118 }
1119