自学教程：C++ BD_DEBUG函数代码示例

META_ROOT *meta_parse(BD_DISC *disc){#ifdef HAVE_LIBXML2    META_ROOT *root = calloc(1, sizeof(META_ROOT));    if (!root) {        BD_DEBUG(DBG_CRIT, "out of memory/n");        return NULL;    }    root->dl_count = 0;    xmlDocPtr doc;    _findMetaXMLfiles(root, disc);    uint8_t i;    for (i = 0; i < root->dl_count; i++) {        uint8_t *data = NULL;        size_t size;        size = disc_read_file(disc, "BDMV" DIR_SEP "META" DIR_SEP "DL",                              root->dl_entries[i].filename,                              &data);        if (!data || size == 0) {            BD_DEBUG(DBG_DIR, "Failed to read BDMV/META/DL/%s/n", root->dl_entries[i].filename);        } else {                doc = xmlReadMemory((char*)data, (int)size, NULL, NULL, 0);                if (doc == NULL) {                    BD_DEBUG(DBG_DIR, "Failed to parse BDMV/META/DL/%s/n", root->dl_entries[i].filename);                } else {                    xmlNode *root_element = NULL;                    root_element = xmlDocGetRootElement(doc);                    root->dl_entries[i].di_name = root->dl_entries[i].di_alternative = NULL;                    root->dl_entries[i].di_num_sets = root->dl_entries[i].di_set_number = -1;                    root->dl_entries[i].toc_count = root->dl_entries[i].thumb_count = 0;                    root->dl_entries[i].toc_entries = NULL;                    root->dl_entries[i].thumbnails = NULL;                    _parseManifestNode(root_element, &root->dl_entries[i]);                    xmlFreeDoc(doc);                }            X_FREE(data);        }    }    xmlCleanupParser();    return root;#else    (void)disc;    BD_DEBUG(DBG_DIR, "configured without libxml2 - can't parse meta info/n");    return NULL;#endif}

static BD_FILE_H *_file_open(const char* filename, const char *cmode){    BD_FILE_H *file;    int fd    = -1;    int flags = 0;    int mode  = 0;    if (strchr(cmode, 'w')) {        flags = O_WRONLY | O_CREAT | O_TRUNC;        mode  = S_IRUSR | S_IWUSR;    } else {        flags = O_RDONLY;    }#ifdef O_CLOEXEC    flags |= O_CLOEXEC;#endif#ifdef O_BINARY    flags |= O_BINARY;#endif    if (strncmp(filename, "myth://", 7) == 0)        return file_open_mythiowrapper(filename, cmode);    if ((fd = open(filename, flags, mode)) < 0) {        BD_DEBUG(DBG_FILE, "Error opening file %s/n", filename);        return NULL;    }    file = calloc(1, sizeof(BD_FILE_H));    if (!file) {        close(fd);        BD_DEBUG(DBG_FILE, "Error opening file %s (out of memory)/n", filename);        return NULL;    }    file->close = _file_close;    file->seek  = _file_seek;    file->read  = _file_read;    file->write = _file_write;    file->tell  = _file_tell;    //file->eof = file_eof_linux;    file->internal = (void*)(intptr_t)fd;    BD_DEBUG(DBG_FILE, "Opened POSIX file %s (%p)/n", filename, (void*)file);    return file;}

BDPLUS_FILE_H *file_open_default(void *handle, const char* file_name){    const char    *device_root = handle;    char          *file_path;    BDPLUS_FILE_H *file;    FILE          *fp;    file_path = str_printf("%s"DIR_SEP"%s", device_root, file_name);    if (!file_path) {        BD_DEBUG(DBG_CRIT, "out of memory/n");        return NULL;    }    fp = fopen(file_path, "rb");    X_FREE(file_path);    if (!fp) {        return NULL;    }    file = calloc(1, sizeof(BDPLUS_FILE_H));    file->internal = fp;    file->close    = _file_close;    file->seek     = _file_seek;    file->read     = _file_read;    return file;}

const char *file_get_config_system(const char *dir){    static char *appdir = NULL;    wchar_t wdir[MAX_PATH];    if (!dir) {        // first call        if (appdir)            return appdir;        /* Get the "Application Data" folder for all users */        if (S_OK == SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE,                    NULL, SHGFP_TYPE_CURRENT, wdir)) {            int len = WideCharToMultiByte (CP_UTF8, 0, wdir, -1, NULL, 0, NULL, NULL);            appdir = malloc(len);            WideCharToMultiByte (CP_UTF8, 0, wdir, -1, appdir, len, NULL, NULL);            return appdir;        } else {            BD_DEBUG(DBG_FILE, "Can't find common configuration directory !/n");            return NULL;        }    } else {        // next call        return NULL;    }    return dir;}

static void _findMetaXMLfiles(META_ROOT *meta, const char *device_path){    BD_DIR_H *dir;    BD_DIRENT ent;    char *path = NULL;    path = str_printf("%s" DIR_SEP "BDMV" DIR_SEP "META" DIR_SEP "DL", device_path);    dir = dir_open(path);    if (dir == NULL) {        BD_DEBUG(DBG_DIR, "Failed to open meta dir %s/n", path);        X_FREE(path);        return;    }    int res;    for (res = dir_read(dir, &ent); !res; res = dir_read(dir, &ent)) {        if (ent.d_name[0] == '.')            continue;        else if (ent.d_name != NULL && strncasecmp(ent.d_name, "bdmt_", 5) == 0) {            uint8_t i = meta->dl_count;            meta->dl_count++;            meta->dl_entries = realloc(meta->dl_entries, (meta->dl_count*sizeof(META_DL)));            meta->dl_entries[i].filename = str_dup(ent.d_name);            strncpy(meta->dl_entries[i].language_code, ent.d_name+5,3);            meta->dl_entries[i].language_code[3] = '/0';            str_tolower(meta->dl_entries[i].language_code);        }    }    dir_close(dir);    X_FREE(path);}

/* * register hook */static void _process_psr_event(void *handle, BD_PSR_EVENT *ev){    GRAPHICS_CONTROLLER *gc = (GRAPHICS_CONTROLLER *)handle;    if (ev->ev_type == BD_PSR_SAVE) {        BD_DEBUG(DBG_GC, "PSR SAVE event/n");        /* save menu page state */        bd_mutex_lock(&gc->mutex);        _save_page_state(gc);        bd_mutex_unlock(&gc->mutex);        return;    }    if (ev->ev_type == BD_PSR_RESTORE) {        switch (ev->psr_idx) {            case PSR_SELECTED_BUTTON_ID:              return;            case PSR_MENU_PAGE_ID:                /* restore menus */                bd_mutex_lock(&gc->mutex);                _restore_page_state(gc);                bd_mutex_unlock(&gc->mutex);                return;            default:                /* others: ignore */                return;        }    }}

static int _decode_segment(PG_DISPLAY_SET *s, PES_BUFFER *p){    BITBUFFER bb;    bb_init(&bb, p->buf, p->len);    uint8_t type   =    bb_read(&bb, 8);    /*uint16_t len = */ bb_read(&bb, 16);    switch (type) {        case PGS_OBJECT:            return _decode_ods(s, &bb, p);        case PGS_PALETTE:            return _decode_pds(s, &bb, p);        case PGS_WINDOW:            return _decode_wds(s, &bb, p);        case PGS_PG_COMPOSITION:            return _decode_pcs(s, &bb, p);        case PGS_IG_COMPOSITION:            return _decode_ics(s, &bb, p);        case PGS_END_OF_DISPLAY:            s->complete = 1;            return 1;        default:            BD_DEBUG(DBG_DECODE | DBG_CRIT, "unknown segment type 0x%x/n", type);            break;    }    return 0;}

static int _load_aes_keys(bdplus_aes_key_t *aes_keys, const char *base){    char *path = str_printf("%s/" AES_KEYS_FILE, base);    uint8_t *keys;    uint32_t size = 0;    uint32_t num_keys, ii;    if (!path) {        return -1;    }    keys = (uint8_t *)file_load(path, &size);    X_FREE(path);    num_keys = size / 16;    if (num_keys > MAX_AES_KEYS) {        num_keys = MAX_AES_KEYS;    }    if (num_keys * 16 != size) {        BD_DEBUG(DBG_FILE | DBG_CRIT, "Invalid AES key file size/n");    }    for (ii = 0; ii < num_keys; ii++) {        memcpy(aes_keys[ii].key, keys + 16*ii, 16);    }    X_FREE(keys);    return num_keys > 6 ? (int)num_keys : -1;}

static int64_t _stream_read(BD_FILE_H *fp, uint8_t *buf, int64_t size){    DEC_STREAM *st = (DEC_STREAM *)fp->internal;    int64_t     result;    if (size != 6144) {        BD_DEBUG(DBG_CRIT, "read size != unit size/n");        return 0;    }    result = st->fp->read(st->fp, buf, size);    if (result <= 0) {        return result;    }    if (st->aacs) {        if (libaacs_decrypt_unit(st->aacs, buf)) {            /* failure is detected from TP header */        }    }    if (st->bdplus) {        if (libbdplus_fixup(st->bdplus, buf, (int)size) < 0) {          /* there's no way to verify if the stream was decoded correctly */        }    }    return result;}

static void _findMetaXMLfiles(META_ROOT *meta, BD_DISC *disc){    BD_DIR_H *dir;    BD_DIRENT ent;    dir = disc_open_dir(disc, "BDMV" DIR_SEP "META" DIR_SEP "DL");    if (dir == NULL) {        BD_DEBUG(DBG_DIR, "Failed to open meta dir BDMV/META/DL//n");        return;    }    int res;    for (res = dir_read(dir, &ent); !res; res = dir_read(dir, &ent)) {        if (ent.d_name[0] == '.')            continue;        else if (strncasecmp(ent.d_name, "bdmt_", 5) == 0) {            META_DL *new_dl_entries = realloc(meta->dl_entries, ((meta->dl_count + 1)*sizeof(META_DL)));            if (new_dl_entries) {                uint8_t i = meta->dl_count;                meta->dl_count++;                meta->dl_entries = new_dl_entries;                memset(&meta->dl_entries[i], 0, sizeof(meta->dl_entries[i]));                meta->dl_entries[i].filename = str_dup(ent.d_name);                strncpy(meta->dl_entries[i].language_code, ent.d_name+5,3);                meta->dl_entries[i].language_code[3] = '/0';                str_tolower(meta->dl_entries[i].language_code);            }        }    }    dir_close(dir);}

static int _decode_interactive_composition(BITBUFFER *bb, BD_IG_INTERACTIVE_COMPOSITION *p){    unsigned ii;    uint32_t data_len = bb_read(bb, 24);    uint32_t buf_len  = bb->p_end - bb->p;    if (data_len != buf_len) {        BD_DEBUG(DBG_DECODE, "ig_decode_interactive(): buffer size mismatch (expected %d, have %d)/n", data_len, buf_len);        return 0;    }    p->stream_model = bb_read(bb, 1);    p->ui_model     = bb_read(bb, 1);    bb_skip(bb, 6);    if (p->stream_model == 0) {        bb_skip(bb, 7);        p->composition_timeout_pts = bb_read_u64(bb, 33);        bb_skip(bb, 7);        p->selection_timeout_pts = bb_read_u64(bb, 33);    }    p->user_timeout_duration = bb_read(bb, 24);    p->num_pages = bb_read(bb, 8);    p->page      = calloc(p->num_pages, sizeof(BD_IG_PAGE));    for (ii = 0; ii < p->num_pages; ii++) {        _decode_page(bb, &p->page[ii]);    }  return 1;}

static int _mobj_parse_object(BITSTREAM *bs, MOBJ_OBJECT *obj){    int i;    obj->resume_intention_flag = bs_read(bs, 1);    obj->menu_call_mask = bs_read(bs, 1);    obj->title_search_mask = bs_read(bs, 1);    bs_skip(bs, 13); /* padding */    obj->num_cmds = bs_read(bs, 16);    obj->cmds     = calloc(obj->num_cmds, sizeof(MOBJ_CMD));    if (!obj->cmds) {        BD_DEBUG(DBG_CRIT, "out of memory/n");        return 0;    }    for (i = 0; i < obj->num_cmds; i++) {        uint8_t buf[12];        bs_read_bytes(bs, buf, 12);        mobj_parse_cmd(buf, &obj->cmds[i]);    }    return 1;}

JNIEXPORT void JNICALL Java_org_videolan_Libbluray_setKeyInterestN(JNIEnv * env,        jclass cls, jlong np, jint mask) {    BLURAY* bd = (BLURAY*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "setKeyInterestN(0x%x)/n", (int)mask);    bd_set_bdj_kit(bd, mask);}

JNIEXPORT void JNICALL Java_org_videolan_Libbluray_setUOMaskN(JNIEnv * env,        jclass cls, jlong np, jboolean menuCallMask, jboolean titleSearchMask) {    BLURAY* bd = (BLURAY*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "setUOMaskN(%d,%d)/n", (int)menuCallMask, (int)titleSearchMask);    bd_set_bdj_uo_mask(bd, ((!!menuCallMask) * BDJ_MENU_CALL_MASK) | ((!!titleSearchMask) * BDJ_TITLE_SEARCH_MASK));}

JNIEXPORT jlong JNICALL Java_org_videolan_Libbluray_getUOMaskN(JNIEnv * env,        jclass cls, jlong np) {    BLURAY* bd = (BLURAY*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "getUOMaskN()/n");    return bd_get_uo_mask(bd);}

static int _parse_app_info(BITSTREAM *bs, INDX_APP_INFO *app_info){    uint32_t len;    if (bs_seek_byte(bs, 40) < 0) {        return 0;    }    len = bs_read(bs, 32);    if (len != 34) {        BD_DEBUG(DBG_NAV, "index.bdmv app_info length is %d, expected 34 !/n", len);    }    bs_skip(bs, 1);    app_info->initial_output_mode_preference = bs_read(bs, 1);    app_info->content_exist_flag             = bs_read(bs, 1);    bs_skip(bs, 5);    app_info->video_format = bs_read(bs, 4);    app_info->frame_rate   = bs_read(bs, 4);    bs_read_bytes(bs, app_info->user_data, 32);    return 1;}

BD_DISC *disc_open(const char *device_path,                   fs_access *p_fs,                   struct bd_enc_info *enc_info,                   const char *keyfile_path,                   void *regs, void *psr_read, void *psr_write){    BD_DISC *p = _disc_init();    if (p) {        if (p_fs && p_fs->open_dir) {            p->fs_handle          = p_fs->fs_handle;            p->pf_file_open_bdrom = p_fs->open_file;            p->pf_dir_open_bdrom  = p_fs->open_dir;        }        _set_paths(p, device_path);#ifdef ENABLE_UDF        /* check if disc root directory can be opened. If not, treat it as device/image file. */        BD_DIR_H *dp_img = device_path ? dir_open(device_path) : NULL;        if (!dp_img) {            void *udf = udf_image_open(device_path, p_fs ? p_fs->fs_handle : NULL, p_fs ? p_fs->read_blocks : NULL);            if (!udf) {                BD_DEBUG(DBG_FILE | DBG_CRIT, "failed opening UDF image %s/n", device_path);            } else {                p->fs_handle          = udf;                p->pf_fs_close        = udf_image_close;                p->pf_file_open_bdrom = udf_file_open;                p->pf_dir_open_bdrom  = udf_dir_open;                p->udf_volid = udf_volume_id(udf);                /* root not accessible with stdio */                X_FREE(p->disc_root);            }        } else {            dir_close(dp_img);            BD_DEBUG(DBG_FILE, "%s does not seem to be image file or device node/n", device_path);        }#endif        struct dec_dev dev = { p->fs_handle, p->pf_file_open_bdrom, p, (file_openFp)disc_open_path, p->disc_root, device_path };        p->dec = dec_init(&dev, enc_info, keyfile_path, regs, psr_read, psr_write);    }    return p;}

static int _parse_index(BITSTREAM *bs, INDX_ROOT *index){    uint32_t index_len, i;    index_len = bs_read(bs, 32);    /* TODO: check if goes to extension data area */    if ((bs_end(bs) - bs_pos(bs))/8 < (int64_t)index_len) {        BD_DEBUG(DBG_NAV | DBG_CRIT, "index.bdmv: invalid index_len %d !/n", index_len);        return 0;    }    if (!_parse_playback_obj(bs, &index->first_play) ||        !_parse_playback_obj(bs, &index->top_menu)) {        return 0;    }    index->num_titles = bs_read(bs, 16);    index->titles = calloc(index->num_titles, sizeof(INDX_TITLE));    for (i = 0; i < index->num_titles; i++) {        index->titles[i].object_type = bs_read(bs, 2);        index->titles[i].access_type = bs_read(bs, 2);        bs_skip(bs, 28);        switch (index->titles[i].object_type) {            case indx_object_type_hdmv:                if (!_parse_hdmv_obj(bs, &index->titles[i].hdmv))                    return 0;                break;            case indx_object_type_bdj:                if (!_parse_bdj_obj(bs, &index->titles[i].bdj))                    return 0;                break;            default:                BD_DEBUG(DBG_NAV | DBG_CRIT, "index.bdmv: unknown object type %d (#%d)/n", index->titles[i].object_type, i);                return 0;        }    }    return 1;}

static void *_load_jvm(const char **p_java_home){#ifdef HAVE_BDJ_J2ME# ifdef _WIN32    static const char *jvm_path[] = {NULL, JDK_HOME};    static const char  jvm_dir[]  = "bin";    static const char  jvm_lib[]  = "cvmi";# else    static const char *jvm_path[] = {NULL, JDK_HOME, "/opt/PhoneME"};    static const char  jvm_dir[]  = "bin";    static const char  jvm_lib[]  = "libcvm";# endif#else# ifdef _WIN32    static const char *jvm_path[] = {NULL, JDK_HOME};    static const char  jvm_dir[]  = "jre/bin/server";    static const char  jvm_lib[]  = "jvm";# else    static const char *jvm_path[] = {NULL, JDK_HOME,                                    "/usr/lib/jvm/default-java",                                    "/usr/lib/jvm/java-6-openjdk",                                    "/usr/lib/jvm/java-7-openjdk",                                    "/etc/java-config-2/current-system-vm"};    static const char  jvm_dir[]  = "jre/lib/" JAVA_ARCH "/server";    static const char  jvm_lib[]  = "libjvm";# endif#endif    const char *java_home = NULL;    unsigned    path_ind;    void       *handle = NULL;    /* JAVA_HOME set, use it */    java_home = getenv("JAVA_HOME");    if (java_home) {        *p_java_home = java_home;        return _jvm_dlopen(java_home, jvm_dir, jvm_lib);    }#if defined(_WIN32) && !defined(HAVE_BDJ_J2ME)    handle = _load_jvm_win32(p_java_home);    if (handle) {        return handle;    }#endif    BD_DEBUG(DBG_BDJ, "JAVA_HOME not set, trying default locations/n");    /* try our pre-defined locations */    for (path_ind = 0; !handle && path_ind < sizeof(jvm_path) / sizeof(jvm_path[0]); path_ind++) {        *p_java_home = jvm_path[path_ind];        handle = _jvm_dlopen(jvm_path[path_ind], jvm_dir, jvm_lib);    }    if (!*p_java_home) {        *p_java_home = dl_get_path();    }    return handle;}

JNIEXPORT jlong JNICALL Java_org_videolan_Libbluray_seekChapterN(JNIEnv * env,        jclass cls, jlong np, jint chapter) {    BDJAVA* bdj = (BDJAVA*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "seekChapterN(%d)/n", (int)chapter);    return bd_seek_chapter(bdj->bd, chapter);}

static int iokit_find_service_matching (MMCDEV *mmc, io_service_t *servp) {    CFMutableDictionaryRef matchingDict = IOServiceMatching("IOBDServices");    io_iterator_t deviceIterator;    io_service_t service;    int rc;    assert (NULL != servp);    *servp = 0;    if (!matchingDict) {        BD_DEBUG(DBG_MMC, "Could not create a matching dictionary for IOBDServices/n");        return -1;    }    /* this call consumes the reference to the matchingDict. we do not need to release it */    rc = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &deviceIterator);    if (kIOReturnSuccess != rc) {        BD_DEBUG(DBG_MMC, "Could not create device iterator/n");        return -1;    }    while (0 != (service = IOIteratorNext (deviceIterator))) {        CFStringRef data;        char name[128] = "";        data = IORegistryEntrySearchCFProperty (service, kIOServicePlane, CFSTR("BSD Name"),                                                kCFAllocatorDefault, kIORegistryIterateRecursively);        if (NULL != data) {            rc = CFStringGetCString (data, name, sizeof (name), kCFStringEncodingASCII);            CFRelease (data);            if (0 == strcmp (name, mmc->bsd_name)) {                break;            }        }        (void) IOObjectRelease (service);    }    IOObjectRelease (deviceIterator);    *servp = service;    return (service) ? 0 : -1;}

static int64_t _file_write(BD_FILE_H *file, const uint8_t *buf, int64_t size){    if (size > 0 && size < BD_MAX_SSIZE) {        return (int64_t)fwrite(buf, 1, (size_t)size, (FILE *)file->internal);    }    if (size == 0) {        if (fflush((FILE *)file->internal)) {            BD_DEBUG(DBG_FILE, "fflush() failed (%p)/n", (void*)file);            return -1;        }        return 0;    }    BD_DEBUG(DBG_FILE | DBG_CRIT, "Ignoring invalid write of size %"PRId64" (%p)/n", size, (void*)file);    return 0;}

JNIEXPORT jint JNICALL Java_org_videolan_Libbluray_selectTitleN(JNIEnv * env,        jclass cls, jlong np, jint title) {    BLURAY* bd = (BLURAY*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "selectTitleN(%d)/n", (int)title);    return bd_play_title_internal(bd, title);}

JNIEXPORT jlong JNICALL Java_org_videolan_Libbluray_seekN(JNIEnv * env,        jclass cls, jlong np, jint playitem, jint playmark, jlong tick) {    BLURAY* bd = (BLURAY*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "seekN(tick=%"PRId64", mark=%d, playitem=%d)/n", (int64_t)tick, (int)playmark, (int)playitem);    return bd_bdj_seek(bd, playitem, playmark, tick);}

JNIEXPORT jint JNICALL Java_org_videolan_Libbluray_writeGPRN(JNIEnv * env,        jclass cls, jlong np, jint num, jint value) {    BDJAVA* bdj = (BDJAVA*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "writeGPRN(%d,%d)/n", (int)num, (int)value);    return bd_gpr_write(bdj->reg, num, value);}

static void _error(const char *msg, int errnum, void *dir){    char buf[128];    if (strerror_r(errnum, buf, sizeof(buf))) {        strcpy(buf, "?");    }    BD_DEBUG(DBG_DIR | DBG_CRIT, "%s: %d %s (%p)/n", msg, errnum, buf, dir);}

JNIEXPORT jlong JNICALL Java_org_videolan_Libbluray_seekPlayItemN(JNIEnv * env,        jclass cls, jlong np, jint clip) {    BDJAVA* bdj = (BDJAVA*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "seekPlayItemN(%d)/n", (int)clip);    return bd_seek_playitem(bdj->bd, clip);}

JNIEXPORT jint JNICALL Java_org_videolan_Libbluray_selectPlaylistN(        JNIEnv * env, jclass cls, jlong np, jint playlist) {    BDJAVA* bdj = (BDJAVA*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "selectPlaylistN(%05d.mpls)/n", (int)playlist);    return bd_select_playlist(bdj->bd, playlist);}

JNIEXPORT jint JNICALL Java_org_videolan_Libbluray_writeGPRN(JNIEnv * env,        jclass cls, jlong np, jint num, jint value) {    BLURAY* bd = (BLURAY*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "writeGPRN(%d,%d)/n", (int)num, (int)value);    return bd_reg_write(bd, 0, num, value, ~0);}

JNIEXPORT jlong JNICALL Java_org_videolan_Libbluray_seekMarkN(JNIEnv * env,        jclass cls, jlong np, jint mark) {    BDJAVA* bdj = (BDJAVA*)(intptr_t)np;    BD_DEBUG(DBG_JNI, "seekMarkN(%d)/n", (int)mark);    return bd_seek_mark(bdj->bd, mark);}