int32 MediaView::MediaPlayer( void *arg) { MediaView* view = (MediaView *)arg; BWindow* window = view->Window(); BBitmap* bitmap = view->fBitmap; BMediaTrack* videoTrack = view->fVideoTrack; BMediaTrack* audioTrack = view->fAudioTrack; BMediaTrack* counterTrack = (videoTrack != NULL) ? videoTrack : audioTrack; AudioOutput* audioOutput = view->fAudioOutput; void* adBuffer = view->fAudioDumpingBuffer; int64 numFrames = counterTrack->CountFrames(); int64 numFramesToSkip = 0; int64 numSkippedFrames = 0; bool scrubbing = false; bool seekNeeded = false; int64 dummy; media_header mh; bigtime_t vStartTime, aStartTime, seekTime, snoozeTime, startTime; bigtime_t curScrubbing, lastScrubbing, lastTime; curScrubbing = lastScrubbing = system_time(); seekTime = 0LL; // Main processing loop (handle stop->start->stop) while (acquire_sem(view->fPlaySem) == B_OK) { release_sem(view->fPlaySem); // as we are doing stop->start, restart audio if needed. if (audioTrack != NULL) audioOutput->Play(); startTime = system_time()-counterTrack->CurrentTime(); // This will loop until the end of the stream while ((counterTrack->CurrentFrame() < numFrames) || scrubbing) { // We are in scrub mode if (acquire_sem(view->fScrubSem) == B_OK) { curScrubbing = system_time(); // We are entering scrub mode if (!scrubbing) { if (audioTrack != NULL) audioOutput->Stop(); scrubbing = true; } // Do a seek. seekNeeded = true; seekTime = view->fScrubTime; } // We are not scrubbing else if (scrubbing) { if (audioTrack != NULL) audioOutput->Play(); scrubbing = false; } // Handle seeking if (seekNeeded) { if (videoTrack) { // Seek the seekTime as close as possible vStartTime = seekTime; videoTrack->SeekToTime(&vStartTime); // Read frames until we get less than 50ms ahead. lastTime = vStartTime; do { bitmap->LockBits(); status_t err = videoTrack->ReadFrames((char*)bitmap->Bits(), &dummy, &mh); bitmap->UnlockBits(); if (err != B_OK) break; vStartTime = mh.start_time; if ((dummy == 0) || (vStartTime <= lastTime)) break; lastTime = vStartTime; } while (seekTime - vStartTime > 50000); } if (audioTrack) { // Seek the extractor as close as possible aStartTime = seekTime; audioOutput->SeekToTime(&aStartTime); // Read frames until we get less than 50ms ahead. lastTime = aStartTime; while (seekTime - aStartTime > 50000) { if (audioTrack->ReadFrames((char *)adBuffer, &dummy, &mh) != B_OK) break; aStartTime = mh.start_time; if ((dummy == 0) || (aStartTime <= lastTime)) break; lastTime = aStartTime; } } else startTime = system_time() - vStartTime; // Set the current time view->fCurTime = seekTime; seekNeeded = false; } // Handle normal playing mode else { // Get the next video frame, if any if (videoTrack != NULL) { bitmap->LockBits(); status_t err = videoTrack->ReadFrames((char*)bitmap->Bits(), &dummy, &mh); bitmap->UnlockBits(); if (err != B_OK) goto do_reset; if (dummy == 0) goto do_reset; vStartTime = mh.start_time; } // Estimated snoozeTime if (audioTrack != NULL) startTime = audioOutput->TrackTimebase(); if (videoTrack != NULL) snoozeTime = vStartTime - (system_time() - startTime); else snoozeTime = 25000; // Handle timing issues if (snoozeTime > 5000LL) { view->fSnoozing = true; snooze(snoozeTime-1000); view->fSnoozing = false; } else if (snoozeTime < -5000) { numSkippedFrames++; numFramesToSkip++; } // Set the current time if (!scrubbing) { view->fCurTime = system_time() - startTime; if (view->fCurTime < seekTime) view->fCurTime = seekTime; } } // Handle the drawing : no drawing if we need to skip a frame... if (numSkippedFrames > 0) numSkippedFrames--; // If we can't lock the window after 50ms, better to give up for // that frame... else if (window->LockWithTimeout(50000) == B_OK) { if ((videoTrack != NULL) && !view->fUsingOverlay) view->DrawBitmap(bitmap, view->VideoBounds()); view->fMediaBar->SetCurTime(view->fCurTime); window->Unlock(); // In scrub mode, don't scrub more than 10 times a second if (scrubbing) { snoozeTime = (100000LL+lastScrubbing) - system_time(); if (snoozeTime > 4000LL) { view->fSnoozing = true; snooze(snoozeTime-1000LL); view->fSnoozing = false; } lastScrubbing = curScrubbing; } } // Check if we are required to stop. if (acquire_sem_etc(view->fPlaySem, 1, B_TIMEOUT, 0) == B_OK) release_sem(view->fPlaySem); // The MediaView asked us to stop. else { if (audioTrack != NULL) audioOutput->Stop(); goto do_restart; } DEBUG("############ Current frame:%Ld, total frame:%Ld\n", counterTrack->CurrentFrame(), numFrames); } // If we exited the main streaming loop because we are at the end, // then we need to loop. if (counterTrack->CurrentFrame() >= numFrames) { do_reset: if (audioTrack != NULL) audioOutput->Stop(); seekNeeded = true; seekTime = 0LL; scrubbing = true; } do_restart:; } return (B_NO_ERROR); }
status_t MediaConverterApp::_ConvertFile(BMediaFile* inFile, BMediaFile* outFile, media_codec_info* audioCodec, media_codec_info* videoCodec, int32 audioQuality, int32 videoQuality, bigtime_t startDuration, bigtime_t endDuration) { BMediaTrack* inVidTrack = NULL; BMediaTrack* inAudTrack = NULL; BMediaTrack* outVidTrack = NULL; BMediaTrack* outAudTrack = NULL; media_format inFormat; media_format outAudFormat; media_format outVidFormat; media_raw_audio_format* raf = NULL; media_raw_video_format* rvf = NULL; int32 width = -1; int32 height = -1; uint8* videoBuffer = NULL; uint8* audioBuffer = NULL; // gather the necessary format information and construct output tracks int64 videoFrameCount = 0; int64 audioFrameCount = 0; status_t ret = B_OK; int32 tracks = inFile->CountTracks(); for (int32 i = 0; i < tracks && (!outAudTrack || !outVidTrack); i++) { BMediaTrack* inTrack = inFile->TrackAt(i); memset(&inFormat, 0, sizeof(media_format)); inTrack->EncodedFormat(&inFormat); if (inFormat.IsAudio() && (audioCodec != NULL)) { inAudTrack = inTrack; memset(&outAudFormat, 0, sizeof(media_format)); outAudFormat.type = B_MEDIA_RAW_AUDIO; raf = &(outAudFormat.u.raw_audio); inTrack->DecodedFormat(&outAudFormat); audioBuffer = new uint8[raf->buffer_size]; // audioFrameSize = (raf->format & media_raw_audio_format::B_AUDIO_SIZE_MASK) // audioFrameSize = (raf->format & 0xf) * raf->channel_count; outAudTrack = outFile->CreateTrack(&outAudFormat, audioCodec); if (outAudTrack != NULL) { if (outAudTrack->SetQuality(audioQuality / 100.0f) != B_OK && fWin->Lock()) { fWin->SetAudioQualityLabel( B_TRANSLATE("Audio quality not supported")); fWin->Unlock(); } } } else if (inFormat.IsVideo() && (videoCodec != NULL)) { inVidTrack = inTrack; width = (int32)inFormat.Width(); height = (int32)inFormat.Height(); // construct desired decoded video format memset(&outVidFormat, 0, sizeof(outVidFormat)); outVidFormat.type = B_MEDIA_RAW_VIDEO; rvf = &(outVidFormat.u.raw_video); rvf->last_active = (uint32)(height - 1); rvf->orientation = B_VIDEO_TOP_LEFT_RIGHT; rvf->display.format = B_RGB32; rvf->display.bytes_per_row = 4 * width; rvf->display.line_width = width; rvf->display.line_count = height; inVidTrack->DecodedFormat(&outVidFormat); if (rvf->display.format == B_RGBA32) { printf("fixing color space (B_RGBA32 -> B_RGB32)"); rvf->display.format = B_RGB32; } // Transfer the display aspect ratio. if (inFormat.type == B_MEDIA_ENCODED_VIDEO) { rvf->pixel_width_aspect = inFormat.u.encoded_video.output.pixel_width_aspect; rvf->pixel_height_aspect = inFormat.u.encoded_video.output.pixel_height_aspect; } else { rvf->pixel_width_aspect = inFormat.u.raw_video.pixel_width_aspect; rvf->pixel_height_aspect = inFormat.u.raw_video.pixel_height_aspect; } videoBuffer = new (std::nothrow) uint8[height * rvf->display.bytes_per_row]; outVidTrack = outFile->CreateTrack(&outVidFormat, videoCodec); if (outVidTrack != NULL) { // DLM Added to use 3ivx Parameter View const char* videoQualitySupport = NULL; BView* encoderView = outVidTrack->GetParameterView(); if (encoderView) { MediaEncoderWindow* encoderWin = new MediaEncoderWindow(BRect(50, 50, 520, 555), encoderView); encoderWin->Go(); // blocks until the window is quit // The quality setting is ignored by the 3ivx encoder if the // view was displayed, but this method is the trigger to read // all the parameter settings outVidTrack->SetQuality(videoQuality / 100.0f); // We can now delete the encoderView created for us by the encoder delete encoderView; encoderView = NULL; videoQualitySupport = B_TRANSLATE("Video using parameters form settings"); } else { if (outVidTrack->SetQuality(videoQuality / 100.0f) >= B_OK) videoQualitySupport = B_TRANSLATE("Video quality not supported"); } if (videoQualitySupport && fWin->Lock()) { fWin->SetVideoQualityLabel(videoQualitySupport); fWin->Unlock(); } } } else { // didn't do anything with the track inFile->ReleaseTrack(inTrack); } } if (!outVidTrack && !outAudTrack) { printf("MediaConverterApp::_ConvertFile() - no tracks found!\n"); ret = B_ERROR; } if (fCancel) { // don't have any video or audio tracks here, or cancelled printf("MediaConverterApp::_ConvertFile()" " - user canceled before transcoding\n"); ret = B_CANCELED; } if (ret < B_OK) { delete[] audioBuffer; delete[] videoBuffer; delete outFile; return ret; } outFile->CommitHeader(); // this is where you would call outFile->AddCopyright(...) int64 framesRead; media_header mh; int32 lastPercent, currPercent; float completePercent; BString status; int64 start; int64 end; int32 stat = 0; // read video from source and write to destination, if necessary if (outVidTrack != NULL) { lastPercent = -1; videoFrameCount = inVidTrack->CountFrames(); if (endDuration == 0 || endDuration < startDuration) { start = 0; end = videoFrameCount; } else { inVidTrack->SeekToTime(&endDuration, stat); end = inVidTrack->CurrentFrame(); inVidTrack->SeekToTime(&startDuration, stat); start = inVidTrack->CurrentFrame(); if (end > videoFrameCount) end = videoFrameCount; if (start > end) start = 0; } framesRead = 0; for (int64 i = start; (i <= end) && !fCancel; i += framesRead) { if ((ret = inVidTrack->ReadFrames(videoBuffer, &framesRead, &mh)) != B_OK) { fprintf(stderr, "Error reading video frame %" B_PRId64 ": %s\n", i, strerror(ret)); snprintf(status.LockBuffer(128), 128, B_TRANSLATE("Error read video frame %" B_PRId64), i); status.UnlockBuffer(); SetStatusMessage(status.String()); break; } if ((ret = outVidTrack->WriteFrames(videoBuffer, framesRead, mh.u.encoded_video.field_flags)) != B_OK) { fprintf(stderr, "Error writing video frame %" B_PRId64 ": %s\n", i, strerror(ret)); snprintf(status.LockBuffer(128), 128, B_TRANSLATE("Error writing video frame %" B_PRId64), i); status.UnlockBuffer(); SetStatusMessage(status.String()); break; } completePercent = (float)(i - start) / (float)(end - start) * 100; currPercent = (int32)completePercent; if (currPercent > lastPercent) { lastPercent = currPercent; snprintf(status.LockBuffer(128), 128, B_TRANSLATE("Writing video track: %" B_PRId32 "%% complete"), currPercent); status.UnlockBuffer(); SetStatusMessage(status.String()); } } outVidTrack->Flush(); inFile->ReleaseTrack(inVidTrack); } // read audio from source and write to destination, if necessary if (outAudTrack != NULL) { lastPercent = -1; audioFrameCount = inAudTrack->CountFrames(); if (endDuration == 0 || endDuration < startDuration) { start = 0; end = audioFrameCount; } else { inAudTrack->SeekToTime(&endDuration, stat); end = inAudTrack->CurrentFrame(); inAudTrack->SeekToTime(&startDuration, stat); start = inAudTrack->CurrentFrame(); if (end > audioFrameCount) end = audioFrameCount; if (start > end) start = 0; } for (int64 i = start; (i <= end) && !fCancel; i += framesRead) { if ((ret = inAudTrack->ReadFrames(audioBuffer, &framesRead, &mh)) != B_OK) { fprintf(stderr, "Error reading audio frames: %s\n", strerror(ret)); snprintf(status.LockBuffer(128), 128, B_TRANSLATE("Error read audio frame %" B_PRId64), i); status.UnlockBuffer(); SetStatusMessage(status.String()); break; } if ((ret = outAudTrack->WriteFrames(audioBuffer, framesRead)) != B_OK) { fprintf(stderr, "Error writing audio frames: %s\n", strerror(ret)); snprintf(status.LockBuffer(128), 128, B_TRANSLATE("Error writing audio frame %" B_PRId64), i); status.UnlockBuffer(); SetStatusMessage(status.String()); break; } completePercent = (float)(i - start) / (float)(end - start) * 100; currPercent = (int32)completePercent; if (currPercent > lastPercent) { lastPercent = currPercent; snprintf(status.LockBuffer(128), 128, B_TRANSLATE("Writing audio track: %" B_PRId32 "%% complete"), currPercent); status.UnlockBuffer(); SetStatusMessage(status.String()); } } outAudTrack->Flush(); inFile->ReleaseTrack(inAudTrack); } outFile->CloseFile(); delete outFile; delete[] videoBuffer; delete[] audioBuffer; return ret; }