/* HBCore.m $ This file is part of the HandBrake source code. Homepage: . It may be used under the terms of the GNU General Public License. */ #import "HBCore.h" #import "HBJob.h" #import "HBJob+HBJobConversion.h" #import "HBDVDDetector.h" #import "HBUtilities.h" #import "HBTitlePrivate.h" #include static BOOL globalInitialized = NO; static void (^errorHandler)(NSString *error) = NULL; static void hb_error_handler(const char *errmsg) { NSString *error = @(errmsg); if (error) { errorHandler(error); } } /** * Private methods of HBCore. */ @interface HBCore () /// Pointer to a hb_state_s struct containing the detailed state information of libhb. @property (nonatomic, readonly) hb_state_t *hb_state; /// Pointer to a libhb handle used by this HBCore instance. @property (nonatomic, readonly) hb_handle_t *hb_handle; /// Current state of HBCore. @property (nonatomic, readwrite) HBState state; /// Timer used to poll libhb for state changes. @property (nonatomic, readwrite) dispatch_source_t updateTimer; @property (nonatomic, readonly) dispatch_queue_t updateTimerQueue; /// Current scanned titles. @property (nonatomic, readwrite, strong) NSArray *titles; /// Progress handler. @property (nonatomic, readwrite, copy) HBCoreProgressHandler progressHandler; /// Completion handler. @property (nonatomic, readwrite, copy) HBCoreCompletionHandler completionHandler; /// User cancelled. @property (nonatomic, readwrite, getter=isCancelled) BOOL cancelled; @end @implementation HBCore + (void)setDVDNav:(BOOL)enabled { hb_dvd_set_dvdnav(enabled); } + (void)initGlobal { hb_global_init(); globalInitialized = YES; } + (void)closeGlobal { NSAssert(globalInitialized, @"[HBCore closeGlobal] global closed but not initialized"); hb_global_close(); } + (void)registerErrorHandler:(void (^)(NSString *error))handler { errorHandler = [handler copy]; hb_register_error_handler(&hb_error_handler); } - (instancetype)init { return [self initWithLogLevel:0]; } - (instancetype)initWithLogLevel:(int)level { self = [super init]; if (self) { _name = @"HBCore"; _state = HBStateIdle; _updateTimerQueue = dispatch_queue_create("fr.handbrake.coreQueue", DISPATCH_QUEUE_SERIAL); _hb_state = malloc(sizeof(struct hb_state_s)); _hb_handle = hb_init(level, 0); if (!_hb_handle) { return nil; } } return self; } - (instancetype)initWithLogLevel:(int)level name:(NSString *)name { self = [self initWithLogLevel:level]; if (self) { _name = [name copy]; } return self; } /** * Releases resources. */ - (void)dealloc { [self stopUpdateTimer]; dispatch_release(_updateTimerQueue); hb_close(&_hb_handle); _hb_handle = NULL; free(_hb_state); } #pragma mark - Scan - (BOOL)canScan:(NSURL *)url error:(NSError * __autoreleasing *)error { if (![[NSFileManager defaultManager] fileExistsAtPath:url.path]) { if (error) { *error = [NSError errorWithDomain:@"HBErrorDomain" code:100 userInfo:@{ NSLocalizedDescriptionKey: @"Unable to find the file at the specified URL" }]; } return NO; } HBDVDDetector *detector = [HBDVDDetector detectorForPath:url.path]; if (detector.isVideoDVD) { // The chosen path was actually on a DVD, so use the raw block // device path instead. [HBUtilities writeToActivityLog:"%s trying to open a physical dvd at: %s", self.name.UTF8String, url.path.UTF8String]; // Notify the user that we don't support removal of copy protection. void *dvdcss = dlopen("libdvdcss.2.dylib", RTLD_LAZY); if (dvdcss) { // libdvdcss was found so all is well [HBUtilities writeToActivityLog:"%s libdvdcss.2.dylib found for decrypting physical dvd", self.name.UTF8String]; dlclose(dvdcss); } else { // compatible libdvdcss not found [HBUtilities writeToActivityLog:"%s, libdvdcss.2.dylib not found for decrypting physical dvd", self.name.UTF8String]; if (error) { *error = [NSError errorWithDomain:@"HBErrorDomain" code:101 userInfo:@{ NSLocalizedDescriptionKey: @"libdvdcss.2.dylib not found for decrypting physical dvd" }]; } } } return YES; } - (void)scanURL:(NSURL *)url titleIndex:(NSUInteger)index previews:(NSUInteger)previewsNum minDuration:(NSUInteger)seconds progressHandler:(HBCoreProgressHandler)progressHandler completionHandler:(HBCoreCompletionHandler)completionHandler { NSAssert(self.state == HBStateIdle, @"[HBCore scanURL:] called while another scan or encode already in progress"); NSAssert(url, @"[HBCore scanURL:] called with nil url."); // Reset the titles array self.titles = nil; // Copy the progress/completion blocks self.progressHandler = progressHandler; self.completionHandler = completionHandler; // Start the timer to handle libhb state changes [self startUpdateTimerWithInterval:0.2]; NSString *path = url.path; HBDVDDetector *detector = [HBDVDDetector detectorForPath:path]; if (detector.isVideoDVD) { // The chosen path was actually on a DVD, so use the raw block // device path instead. path = detector.devicePath; } // convert minTitleDuration from seconds to the internal HB time uint64_t min_title_duration_ticks = 90000LL * seconds; // If there is no title number passed to scan, we use 0 // which causes the default behavior of a full source scan if (index > 0) { [HBUtilities writeToActivityLog:"%s scanning specifically for title: %d", self.name.UTF8String, index]; } else { // minimum title duration doesn't apply to title-specific scan // it doesn't apply to batch scan either, but we can't tell it apart from DVD & BD folders here [HBUtilities writeToActivityLog:"%s scanning titles with a duration of %d seconds or more", self.name.UTF8String, seconds]; } hb_system_sleep_prevent(_hb_handle); hb_scan(_hb_handle, path.fileSystemRepresentation, (int)index, (int)previewsNum, 1, min_title_duration_ticks); // Set the state, so the UI can be update // to reflect the current state instead of // waiting for libhb to set it in a background thread. self.state = HBStateScanning; } /** * Creates an array of lightweight HBTitles instances. */ - (BOOL)scanDone { if (self.isCancelled) { return NO; } hb_title_set_t *title_set = hb_get_title_set(_hb_handle); NSMutableArray *titles = [NSMutableArray array]; for (int i = 0; i < hb_list_count(title_set->list_title); i++) { hb_title_t *title = (hb_title_t *) hb_list_item(title_set->list_title, i); [titles addObject:[[HBTitle alloc] initWithTitle:title featured:(title->index == title_set->feature)]]; } self.titles = [titles copy]; [HBUtilities writeToActivityLog:"%s scan done", self.name.UTF8String]; return (self.titles.count > 0); } - (void)cancelScan { self.cancelled = YES; hb_scan_stop(_hb_handle); [HBUtilities writeToActivityLog:"%s scan cancelled", self.name.UTF8String]; } #pragma mark - Preview images - (CGImageRef)copyImageAtIndex:(NSUInteger)index forTitle:(HBTitle *)title pictureFrame:(HBPicture *)frame deinterlace:(BOOL)deinterlace { CGImageRef img = NULL; hb_geometry_settings_t geo; memset(&geo, 0, sizeof(geo)); geo.geometry.width = frame.displayWidth; geo.geometry.height = frame.height; // ignore the par. geo.geometry.par.num = 1; geo.geometry.par.den = 1; int crop[4] = {frame.cropTop, frame.cropBottom, frame.cropLeft, frame.cropRight}; memcpy(geo.crop, crop, sizeof(int[4])); hb_image_t *image = hb_get_preview2(_hb_handle, title.index, (int)index, &geo, deinterlace); if (image) { // Create an CGImageRef and copy the libhb image into it. // The image data returned by hb_get_preview2 is 4 bytes per pixel, BGRA format. // Alpha is ignored. CGBitmapInfo bitmapInfo = kCGBitmapByteOrderDefault | kCGImageAlphaNone; CFMutableDataRef imgData = CFDataCreateMutable(kCFAllocatorDefault, 3 * image->width * image->height); CGDataProviderRef provider = CGDataProviderCreateWithCFData(imgData); CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB(); img = CGImageCreate(image->width, image->height, 8, 24, image->width * 3, colorSpace, bitmapInfo, provider, NULL, NO, kCGRenderingIntentDefault); CGColorSpaceRelease(colorSpace); CGDataProviderRelease(provider); CFRelease(imgData); UInt8 *src_line = image->data; UInt8 *dst = CFDataGetMutableBytePtr(imgData); for (int r = 0; r < image->height; r++) { UInt8 *src = src_line; for (int c = 0; c < image->width; c++) { *dst++ = src[2]; *dst++ = src[1]; *dst++ = src[0]; src += 4; } src_line += image->plane[0].stride; } hb_image_close(&image); } return img; } - (NSUInteger)imagesCountForTitle:(HBTitle *)title { return title.hb_title->preview_count; } #pragma mark - Encodes - (void)encodeJob:(HBJob *)job progressHandler:(HBCoreProgressHandler)progressHandler completionHandler:(HBCoreCompletionHandler)completionHandler; { NSAssert(self.state == HBStateIdle, @"[HBCore encodeJob:] called while another scan or encode already in progress"); NSAssert(job, @"[HBCore encodeJob:] called with nil job"); // Copy the progress/completion blocks self.progressHandler = progressHandler; self.completionHandler = completionHandler; // Start the timer to handle libhb state changes [self startUpdateTimerWithInterval:0.5]; // Add the job to libhb hb_job_t *hb_job = job.hb_job; hb_job_set_file(hb_job, job.destURL.path.fileSystemRepresentation); hb_add(_hb_handle, hb_job); // Free the job hb_job_close(&hb_job); hb_system_sleep_prevent(_hb_handle); hb_start(_hb_handle); // Set the state, so the UI can be update // to reflect the current state instead of // waiting for libhb to set it in a background thread. self.state = HBStateWorking; [HBUtilities writeToActivityLog:"%s started encoding %s", self.name.UTF8String, job.destURL.lastPathComponent.UTF8String]; } - (BOOL)workDone { // HB_STATE_WORKDONE happpens as a result of libhb finishing all its jobs // or someone calling hb_stop. In the latter case, hb_stop does not clear // out the remaining passes/jobs in the queue. We'll do that here. hb_job_t *job; while ((job = hb_job(_hb_handle, 0))) { hb_rem(_hb_handle, job); } [HBUtilities writeToActivityLog:"%s work done", self.name.UTF8String]; return self.isCancelled || (_hb_state->param.workdone.error == 0); } - (void)cancelEncode { self.cancelled = YES; hb_stop(_hb_handle); [HBUtilities writeToActivityLog:"%s encode cancelled", self.name.UTF8String]; } - (void)pause { hb_pause(_hb_handle); hb_system_sleep_allow(_hb_handle); self.state = HBStatePaused; } - (void)resume { hb_resume(_hb_handle); hb_system_sleep_prevent(_hb_handle); self.state = HBStateWorking; } #pragma mark - State updates /** * Starts the timer used to polls libhb for state changes. * * @param seconds The number of seconds between firings of the timer. */ - (void)startUpdateTimerWithInterval:(NSTimeInterval)seconds { if (!self.updateTimer) { dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue()); if (timer) { dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), (uint64_t)(seconds * NSEC_PER_SEC), (uint64_t)(seconds * NSEC_PER_SEC / 10)); dispatch_source_set_event_handler(timer, ^{ [self updateState]; }); dispatch_resume(timer); } self.updateTimer = timer; } } /** * Stops the update timer. */ - (void)stopUpdateTimer { if (self.updateTimer) { dispatch_source_cancel(self.updateTimer); dispatch_release(self.updateTimer); self.updateTimer = NULL; } } /** * This method polls libhb continuously for state changes and processes them. * Additional processing for each state is performed in methods that start * with 'handle'. */ - (void)updateState { hb_get_state(_hb_handle, _hb_state); if (_hb_state->state == HB_STATE_IDLE) { // Libhb reported HB_STATE_IDLE, so nothing interesting has happened. return; } // Update HBCore state to reflect the current state of libhb self.state = _hb_state->state; // Call the handler for the current state if (_hb_state->state == HB_STATE_WORKDONE || _hb_state->state == HB_STATE_SCANDONE) { [self handleCompletion]; } else { [self handleProgress]; } } #pragma mark - Blocks callbacks /** * Processes progress state information. */ - (void)handleProgress { if (self.progressHandler) { self.progressHandler(self.state, *(self.hb_state)); } } /** * Processes completion state information. */ - (void)handleCompletion { // Libhb reported HB_STATE_WORKDONE or HB_STATE_SCANDONE, // so nothing interesting will happen after this point, stop the timer. [self stopUpdateTimer]; // Set the state to idle, because the update timer won't fire again. self.state = HBStateIdle; // Reallow system sleep. hb_system_sleep_allow(_hb_handle); // Call the completion block and clean ups the handlers self.progressHandler = nil; if (_hb_state->state == HB_STATE_WORKDONE) { [self handleWorkCompletion]; } else { [self handleScanCompletion]; } // Reset the cancelled state. self.cancelled = NO; } /** * Runs the completion block and clean ups the internal blocks. * * @param result the result to pass to the completion block. */ - (void)runCompletionBlockAndCleanUpWithResult:(BOOL)result { if (self.completionHandler) { // Retain the completion block, because it could be replaced // inside the same block. HBCoreCompletionHandler completionHandler = self.completionHandler; self.completionHandler = nil; completionHandler(result); } } /** * Processes scan completion. */ - (void)handleScanCompletion { BOOL result = [self scanDone]; [self runCompletionBlockAndCleanUpWithResult:result]; } /** * Processes work completion. */ - (void)handleWorkCompletion { BOOL result = [self workDone]; [self runCompletionBlockAndCleanUpWithResult:result]; } @end