From 10990cfeff28ec811fdf4a84b3c4a884d0bdd202 Mon Sep 17 00:00:00 2001 From: Craig Labenz Date: Mon, 13 Nov 2023 12:05:10 -0800 Subject: [PATCH 1/6] Adds mediapipe_core package (#11) * adds mediapipe_core package * adds makefile for all packages * fixes typo in Makefile * Apply suggestions from code review * Update Makefile * Apply suggestions from code review * updated generated code's location and license (for 3P status) * code review responses including: * comments * licensing * resolving testing nits * updated README * setup sharing of base analysis_options * Update packages/mediapipe-core/lib/src/containers.dart Co-authored-by: Kate Lovett * Update packages/mediapipe-core/lib/src/containers.dart Co-authored-by: Kate Lovett * add free methods to core structs * code review updates to options * adds publish blocker * Add GitHub actions for CI/CD (#14) * adds CI/CD for mediapipe_core * add newlines * moves file into workflows dir * uncomment flutter doctor * testing PR config to run this now * added master and beta CI scripts * add executable permissions to CI scripts * adds ffiwrapper to ci/cd --------- Co-authored-by: Kate Lovett --- .github/workflows/main.yaml | 36 ++ Makefile | 43 +++ packages/analysis_options.yaml | 6 + packages/mediapipe-core/.gitignore | 7 + packages/mediapipe-core/CHANGELOG.md | 3 + packages/mediapipe-core/README.md | 27 ++ packages/mediapipe-core/analysis_options.yaml | 5 + packages/mediapipe-core/ffigen.yaml | 26 ++ .../lib/generated/core_symbols.yaml | 38 ++ .../mediapipe-core/lib/mediapipe_core.dart | 11 + .../mediapipe-core/lib/src/containers.dart | 162 ++++++++ .../mediapipe-core/lib/src/ffi_utils.dart | 78 ++++ .../mediapipe-core/lib/src/task_options.dart | 175 +++++++++ .../generated/mediapipe_common_bindings.dart | 347 ++++++++++++++++++ packages/mediapipe-core/pubspec.yaml | 20 + .../test/task_options_test.dart | 110 ++++++ .../tasks/c/components/containers/category.h | 50 +++ .../containers/classification_result.h | 70 ++++ .../processors/classifier_options.h | 61 +++ .../mediapipe/tasks/c/core/base_options.h | 36 ++ tool/ci_script_shared.sh | 28 ++ tool/mediapipe_ci_script_beta.sh | 16 + tool/mediapipe_ci_script_master.sh | 16 + tool/mediapipe_ci_script_stable.sh | 16 + 24 files changed, 1387 insertions(+) create mode 100644 .github/workflows/main.yaml create mode 100644 Makefile create mode 100644 packages/analysis_options.yaml create mode 100644 packages/mediapipe-core/.gitignore create mode 100644 packages/mediapipe-core/CHANGELOG.md create mode 100644 packages/mediapipe-core/README.md create mode 100644 packages/mediapipe-core/analysis_options.yaml create mode 100644 packages/mediapipe-core/ffigen.yaml create mode 100644 packages/mediapipe-core/lib/generated/core_symbols.yaml create mode 100644 packages/mediapipe-core/lib/mediapipe_core.dart create mode 100644 packages/mediapipe-core/lib/src/containers.dart create mode 100644 packages/mediapipe-core/lib/src/ffi_utils.dart create mode 100644 packages/mediapipe-core/lib/src/task_options.dart create mode 100644 packages/mediapipe-core/lib/src/third_party/mediapipe/generated/mediapipe_common_bindings.dart create mode 100644 packages/mediapipe-core/pubspec.yaml create mode 100644 packages/mediapipe-core/test/task_options_test.dart create mode 100644 packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/category.h create mode 100644 packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/classification_result.h create mode 100644 packages/mediapipe-core/third_party/mediapipe/tasks/c/components/processors/classifier_options.h create mode 100644 packages/mediapipe-core/third_party/mediapipe/tasks/c/core/base_options.h create mode 100644 tool/ci_script_shared.sh create mode 100755 tool/mediapipe_ci_script_beta.sh create mode 100755 tool/mediapipe_ci_script_master.sh create mode 100755 tool/mediapipe_ci_script_stable.sh diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml new file mode 100644 index 0000000..45325b8 --- /dev/null +++ b/.github/workflows/main.yaml @@ -0,0 +1,36 @@ +name: Main Branch CI + +# Declare default permissions as read only. +permissions: read-all + +on: + push: + branches: [main] + pull_request: + branches: [main, ffi-wrapper, ffi-wrapper-core-pkg] + workflow_dispatch: + schedule: + - cron: "0 0 * * *" # Every day at midnight + +defaults: + run: + shell: bash + +jobs: + flutter-tests: + name: Test mediapipe_core against ${{ matrix.flutter_version }} + runs-on: ${{ matrix.os }} + # Skip running job on forks + if: github.repository == 'google/flutter-mediapipe' + strategy: + fail-fast: false + matrix: + flutter_version: [stable, beta, master] + # TODO(craiglabenz): Add `ubuntu-latest` and `windows-latest` when those artifacts exist + os: [macos-latest] + steps: + - uses: actions/checkout@v4 + - uses: subosito/flutter-action@v2 + with: + channel: ${{ matrix.flutter_version }} + - run: ./tool/mediapipe_ci_script_${{ matrix.flutter_version }}.sh diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..84f0a67 --- /dev/null +++ b/Makefile @@ -0,0 +1,43 @@ +# Runs the utility to pull in all header files from `google/mediapipe` +headers: + cd packages/build_cmd && dart bin/main.dart headers + +# Runs `ffigen` for all packages +generate: generate_core generate_text + +# Runs `ffigen` for all packages, compiles the faked C artifacts, and runs all tests +test: generate_text test_text generate_core test_core + +# Runs `ffigen` for all packages and all tests for all packages +test_only: test_core test_text + +# Core --- + +# Runs `ffigen` for `mediapipe_core` +generate_core: + cd packages/mediapipe-core && dart run ffigen --config=ffigen.yaml + +# Runs unit tests for `mediapipe_core` +test_core: + cd packages/mediapipe-core && dart test + +# Text --- + +# Runs `ffigen` for `mediapipe_text` +generate_text: + cd packages/mediapipe-task-text && dart run ffigen --config=ffigen.yaml + +# Compiles the faked C artifacts for testing +compile_fake_text: + # Builds standalone executable + cd packages/mediapipe-task-text/test/c && gcc fake_text_classifier.c -o fake_text_classifier + # Builds what Flutter needs + cd packages/mediapipe-task-text/test/c && gcc -static -c -fPIC *.c -o fake_text_classifier.o + cd packages/mediapipe-task-text/test/c && gcc -shared -o fake_text_classifier.dylib fake_text_classifier.o + +# Runs `ffigen` for `mediapipe_text` and all text tests +test_text: compile_fake_text test_text_only + +# Runs all text tests +test_text_only: + cd packages/mediapipe-task-text && flutter test diff --git a/packages/analysis_options.yaml b/packages/analysis_options.yaml new file mode 100644 index 0000000..c4d43fe --- /dev/null +++ b/packages/analysis_options.yaml @@ -0,0 +1,6 @@ +include: package:lints/recommended.yaml + +linter: + rules: + - public_member_api_docs # see https://github.com/flutter/flutter/wiki/Style-guide-for-Flutter-repo#documentation-dartdocs-javadocs-etc + diff --git a/packages/mediapipe-core/.gitignore b/packages/mediapipe-core/.gitignore new file mode 100644 index 0000000..3cceda5 --- /dev/null +++ b/packages/mediapipe-core/.gitignore @@ -0,0 +1,7 @@ +# https://dart.dev/guides/libraries/private-files +# Created by `dart pub` +.dart_tool/ + +# Avoid committing pubspec.lock for library packages; see +# https://dart.dev/guides/libraries/private-files#pubspeclock. +pubspec.lock diff --git a/packages/mediapipe-core/CHANGELOG.md b/packages/mediapipe-core/CHANGELOG.md new file mode 100644 index 0000000..b78d64c --- /dev/null +++ b/packages/mediapipe-core/CHANGELOG.md @@ -0,0 +1,3 @@ +## 0.0.1 + +- Initial version. diff --git a/packages/mediapipe-core/README.md b/packages/mediapipe-core/README.md new file mode 100644 index 0000000..124460d --- /dev/null +++ b/packages/mediapipe-core/README.md @@ -0,0 +1,27 @@ +# MediaPipe Core for Flutter + +![pub package](https://img.shields.io/pub/v/mediapipe_core) + +A Flutter plugin to use the MediaPipe Core API, which enables multiple Mediapipe tasks. + +To learn more about MediaPipe, please visit the [MediaPipe website](https://developers.google.com/mediapipe) + +## Getting Started + +To get started with MediaPipe, please [see the documentation](https://developers.google.com/mediapipe/solutions/guide). + + + +## Issues and feedback + +Please file Flutter-MediaPipe specific issues, bugs, or feature requests in our [issue tracker](https://github.com/google/flutter-mediapipe/issues/new). + +Issues that are specific to Flutter can be filed in the [Flutter issue tracker](https://github.com/flutter/flutter/issues/new). + +To contribute a change to this plugin, +please review our [contribution guide](https://github.com/google/flutter-mediapipe/blob/master/CONTRIBUTING.md) +and open a [pull request](https://github.com/google/flutter-mediapipe/pulls). \ No newline at end of file diff --git a/packages/mediapipe-core/analysis_options.yaml b/packages/mediapipe-core/analysis_options.yaml new file mode 100644 index 0000000..f2aa915 --- /dev/null +++ b/packages/mediapipe-core/analysis_options.yaml @@ -0,0 +1,5 @@ +include: ../analysis_options.yaml + +analyzer: + exclude: + - "**/mediapipe_common_bindings.dart" diff --git a/packages/mediapipe-core/ffigen.yaml b/packages/mediapipe-core/ffigen.yaml new file mode 100644 index 0000000..547b1aa --- /dev/null +++ b/packages/mediapipe-core/ffigen.yaml @@ -0,0 +1,26 @@ +name: "MediaPipeCommonBindings" +description: "Bindings for shared MediaPipe structs common across many tasks" +output: + bindings: "lib/src/third_party/mediapipe/generated/mediapipe_common_bindings.dart" + symbol-file: + output: "package:mediapipe_core/generated/core_symbols.yaml" + import-path: "package:mediapipe_core/src/third_party/mediapipe/generated/mediapipe_common_bindings.dart" +headers: + entry-points: + - "third_party/mediapipe/tasks/c/**" +preamble: | + /* Copyright 2023 The MediaPipe Authors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + ==============================================================================*/ +ffi-native: diff --git a/packages/mediapipe-core/lib/generated/core_symbols.yaml b/packages/mediapipe-core/lib/generated/core_symbols.yaml new file mode 100644 index 0000000..95f3c22 --- /dev/null +++ b/packages/mediapipe-core/lib/generated/core_symbols.yaml @@ -0,0 +1,38 @@ +format_version: 1.0.0 +files: + package:mediapipe_core/src/third_party/mediapipe/generated/mediapipe_common_bindings.dart: + used-config: + ffi-native: false + symbols: + c:@S@BaseOptions: + name: BaseOptions + c:@S@Category: + name: Category + c:@S@ClassificationResult: + name: ClassificationResult + c:@S@Classifications: + name: Classifications + c:@S@ClassifierOptions: + name: ClassifierOptions + c:@S@__darwin_pthread_handler_rec: + name: __darwin_pthread_handler_rec + c:@S@_opaque_pthread_attr_t: + name: _opaque_pthread_attr_t + c:@S@_opaque_pthread_cond_t: + name: _opaque_pthread_cond_t + c:@S@_opaque_pthread_condattr_t: + name: _opaque_pthread_condattr_t + c:@S@_opaque_pthread_mutex_t: + name: _opaque_pthread_mutex_t + c:@S@_opaque_pthread_mutexattr_t: + name: _opaque_pthread_mutexattr_t + c:@S@_opaque_pthread_once_t: + name: _opaque_pthread_once_t + c:@S@_opaque_pthread_rwlock_t: + name: _opaque_pthread_rwlock_t + c:@S@_opaque_pthread_rwlockattr_t: + name: _opaque_pthread_rwlockattr_t + c:@S@_opaque_pthread_t: + name: _opaque_pthread_t + c:@UA@__mbstate_t: + name: __mbstate_t diff --git a/packages/mediapipe-core/lib/mediapipe_core.dart b/packages/mediapipe-core/lib/mediapipe_core.dart new file mode 100644 index 0000000..7bb29ef --- /dev/null +++ b/packages/mediapipe-core/lib/mediapipe_core.dart @@ -0,0 +1,11 @@ +// Copyright 2014 The Flutter Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +/// Package containing core dependencies for MediaPipe's text, vision, and +/// audio-based tasks. +library; + +export 'src/containers.dart' show Category, Classifications; +export 'src/ffi_utils.dart'; +export 'src/task_options.dart' show BaseOptions, ClassifierOptions; diff --git a/packages/mediapipe-core/lib/src/containers.dart b/packages/mediapipe-core/lib/src/containers.dart new file mode 100644 index 0000000..5111040 --- /dev/null +++ b/packages/mediapipe-core/lib/src/containers.dart @@ -0,0 +1,162 @@ +// Copyright 2014 The Flutter Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +import 'dart:ffi'; +import 'package:ffi/ffi.dart'; +import 'package:mediapipe_core/mediapipe_core.dart'; +import 'third_party/mediapipe/generated/mediapipe_common_bindings.dart' + as bindings; + +/// Dart representation of MediaPipe's "Category" concept. +/// +/// Category is a util class, that contains a [categoryName], its [displayName], +/// a float value as [score], and the [index] of the label in the corresponding +/// label file. Typically it's used as result of classification or detection +/// tasks. +/// +/// See more: +/// * [MediaPipe's Category documentation](https://developers.google.com/mediapipe/api/solutions/java/com/google/mediapipe/tasks/components/containers/Category) +class Category { + /// Generative constructor that creates a [Category] instance. + const Category({ + required this.index, + required this.score, + required this.categoryName, + required this.displayName, + }); + + /// The index of the label in the corresponding label file. + final int index; + + /// The probability score of this label category. + final double score; + + /// The label of this category object. + final String? categoryName; + + /// The display name of the label, which may be translated for different locales. + final String? displayName; + + /// Accepts a pointer to a list of structs, and a count representing the length + /// of the list, and returns a list of pure-Dart [Category] instances. + static List fromStructs( + Pointer structs, + int count, + ) { + final categories = []; + for (int i = 0; i < count; i++) { + categories.add(fromStruct(structs[i])); + } + return categories; + } + + /// Accepts a pointer to a single struct and returns a pure-Dart [Category] instance. + static Category fromStruct(bindings.Category struct) { + return Category( + index: struct.index, + score: struct.score, + categoryName: toDartString(struct.category_name), + displayName: toDartString(struct.display_name), + ); + } + + /// Releases all C memory associated with a list of [bindings.Category] pointers. + /// This method is important to call after calling [Category.fromStructs] to + /// convert that C memory into pure-Dart objects. + static void freeStructs(Pointer structs, int count) { + int index = 0; + while (index < count) { + bindings.Category obj = structs[index]; + calloc.free(obj.category_name); + calloc.free(obj.display_name); + index++; + } + calloc.free(structs); + } + + @override + String toString() => 'Category(index=$index, score=$score, ' + 'categoryName=$categoryName, displayName=$displayName)'; +} + +/// Dart representation of MediaPipe's "Classifications" concept. +/// +/// Represents the list of classification for a given classifier head. +/// Typically used as a result for classification tasks. +/// +/// See also: +/// * [MediaPipe's Classifications documentation](https://developers.google.com/mediapipe/api/solutions/java/com/google/mediapipe/tasks/components/containers/Classifications) +class Classifications { + /// Generative constructor that creates a [Classifications] instance. + const Classifications({ + required this.categories, + required this.headIndex, + required this.headName, + }); + + /// A list of [Category] objects which contain the actual classification + /// information, including human-readable labels and probability scores. + final List categories; + + /// The index of the classifier head these entries refer to. + final int headIndex; + + /// The optional name of the classifier head, which is the corresponding + /// tensor metadata name. + final String? headName; + + /// Accepts a pointer to a list of structs, and a count representing the length + /// of the list, and returns a list of pure-Dart [Classifications] instances. + static List fromStructs( + Pointer structs, + int count, + ) { + final classifications = []; + for (int i = 0; i < count; i++) { + classifications.add(fromStruct(structs[i])); + } + return classifications; + } + + /// Accepts a pointer to a single struct and returns a pure-Dart [Classifications] + /// instance. + static Classifications fromStruct(bindings.Classifications struct) { + return Classifications( + categories: Category.fromStructs( + struct.categories, + struct.categories_count, + ), + headIndex: struct.head_index, + headName: toDartString(struct.head_name), + ); + } + + /// Releases all C memory associated with a list of [bindings.Classifications] + /// pointers. This method is important to call after calling [Classifications.fromStructs] + /// to convert that C memory into pure-Dart objects. + static void freeStructs( + Pointer structs, + int count, + ) { + int index = 0; + while (index < count) { + bindings.Classifications obj = structs[index]; + Category.freeStructs(obj.categories, obj.categories_count); + calloc.free(obj.head_name); + index++; + } + calloc.free(structs); + } + + /// Convenience getter for the first [Category] out of the [categories] list. + Category? get firstCategory => + categories.isNotEmpty ? categories.first : null; + + @override + String toString() { + final categoryStrings = categories.map((cat) => cat.toString()).join(', '); + return 'Classification(categories=[$categoryStrings], ' + 'headIndex=$headIndex, headName=$headName)'; + } +} diff --git a/packages/mediapipe-core/lib/src/ffi_utils.dart b/packages/mediapipe-core/lib/src/ffi_utils.dart new file mode 100644 index 0000000..a5411c9 --- /dev/null +++ b/packages/mediapipe-core/lib/src/ffi_utils.dart @@ -0,0 +1,78 @@ +// Copyright 2014 The Flutter Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +import 'dart:ffi'; +import 'dart:typed_data'; +import 'package:ffi/ffi.dart'; + +/// Converts a list of Dart strings into their C memory equivalent. +/// +/// See also: +/// * [prepareString] +Pointer> prepareListOfStrings(List values) { + final ptrArray = calloc>(values.length); + for (var i = 0; i < values.length; i++) { + ptrArray[i] = prepareString(values[i]); + } + return ptrArray; +} + +/// Converts a single Dart string into its C memory equivalent. +/// +/// See also: +/// * [prepareListOfStrings] +Pointer prepareString(String val) => val.toNativeUtf8().cast(); + +/// Converts the C memory representation of a string into a Dart [String]. If the +/// supplied pointer is a null pointer, this function returns `null`. +/// +/// See also: +/// * [toDartStrings] +String? toDartString(Pointer val) { + if (val.address == 0) return null; + return val.cast().toDartString(); +} + +/// Converts a list of C memory representations of strings into a list of Dart +/// [String]s. +/// +/// See also: +/// * [toDartString] +List toDartStrings(Pointer> val, int length) { + final dartStrings = []; + int counter = 0; + while (counter < length) { + dartStrings.add(toDartString(val[counter])); + counter++; + } + return dartStrings; +} + +/// Converts Dart's representation for binary data, a [Uint8List], into its C +/// memory representation. +Pointer prepareUint8List(Uint8List ints) { + final Pointer ptr = calloc(ints.length); + ptr.asTypedList(ints.length).setAll(0, ints); + return ptr.cast(); +} + +/// Converts a pointer to binary data in C memory to Dart's representation for +/// binary data, a [Uint8List]. +Uint8List toUint8List(Pointer val, {int? length}) { + final codeUnits = val.cast(); + if (length != null) { + RangeError.checkNotNegative(length, 'length'); + } else { + length = _length(codeUnits); + } + return codeUnits.asTypedList(length); +} + +int _length(Pointer codeUnits) { + var length = 0; + while (codeUnits[length] != 0) { + length++; + } + return length; +} diff --git a/packages/mediapipe-core/lib/src/task_options.dart b/packages/mediapipe-core/lib/src/task_options.dart new file mode 100644 index 0000000..c12ff61 --- /dev/null +++ b/packages/mediapipe-core/lib/src/task_options.dart @@ -0,0 +1,175 @@ +// Copyright 2014 The Flutter Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +import 'dart:ffi'; +import 'dart:typed_data'; +import 'package:equatable/equatable.dart'; +import 'package:ffi/ffi.dart'; +import 'ffi_utils.dart'; +import 'third_party/mediapipe/generated/mediapipe_common_bindings.dart' + as bindings; + +/// Dart representation of MediaPipe's "BaseOptions" concept. +/// +/// Used to configure various classifiers by specifying the model they will use +/// for computation. +/// +/// See also: +/// * [MediaPipe's BaseOptions documentation](https://developers.google.com/mediapipe/api/solutions/java/com/google/mediapipe/tasks/core/BaseOptions) +/// * [ClassifierOptions], which is often used in conjunction to specify a +/// classifier's desired behavior. +class BaseOptions extends Equatable { + /// Generative constructor that creates a [BaseOptions] instance. + const BaseOptions({this.modelAssetBuffer, this.modelAssetPath}) + : assert( + !(modelAssetBuffer == null && modelAssetPath == null), + 'You must supply either `modelAssetBuffer` or `modelAssetPath`', + ), + assert( + !(modelAssetBuffer != null && modelAssetPath != null), + 'You must only supply one of `modelAssetBuffer` and `modelAssetPath`', + ); + + /// The model asset file contents as bytes; + final Uint8List? modelAssetBuffer; + + /// Path to the model asset file. + final String? modelAssetPath; + + /// Converts this pure-Dart representation into C-memory suitable for the + /// MediaPipe SDK to instantiate various classifiers. + Pointer toStruct() { + final struct = calloc(); + + if (modelAssetPath != null) { + struct.ref.model_asset_path = prepareString(modelAssetPath!); + } + if (modelAssetBuffer != null) { + struct.ref.model_asset_buffer = prepareUint8List(modelAssetBuffer!); + } + return struct; + } + + @override + List get props => [modelAssetBuffer, modelAssetPath]; + + /// Releases all C memory held by this [bindings.BaseOptions] struct. + static void freeStruct(bindings.BaseOptions struct) { + if (struct.model_asset_buffer.address != 0) { + calloc.free(struct.model_asset_buffer); + } + if (struct.model_asset_path.address != 0) { + calloc.free(struct.model_asset_path); + } + } +} + +/// Dart representation of MediaPipe's "ClassifierOptions" concept. +/// +/// Classifier options shared across MediaPipe classification tasks. +/// +/// See also: +/// * [MediaPipe's ClassifierOptions documentation](https://developers.google.com/mediapipe/api/solutions/java/com/google/mediapipe/tasks/components/processors/ClassifierOptions) +/// * [BaseOptions], which is often used in conjunction to specify a +/// classifier's desired behavior. +class ClassifierOptions extends Equatable { + /// Generative constructor that creates a [ClassifierOptions] instance. + const ClassifierOptions({ + this.displayNamesLocale, + this.maxResults, + this.scoreThreshold, + this.categoryAllowlist, + this.categoryDenylist, + }); + + /// The locale to use for display names specified through the TFLite Model + /// Metadata. + final String? displayNamesLocale; + + /// The maximum number of top-scored classification results to return. + final int? maxResults; + + /// If set, establishes a minimum `score` and leads to the rejection of any + /// categories with lower `score` values. + final double? scoreThreshold; + + /// Allowlist of category names. + /// + /// If non-empty, classification results whose category name is not in + /// this set will be discarded. Duplicate or unknown category names + /// are ignored. Mutually exclusive with `categoryDenylist`. + final List? categoryAllowlist; + + /// Denylist of category names. + /// + /// If non-empty, classification results whose category name is in this set + /// will be discarded. Duplicate or unknown category names are ignored. + /// Mutually exclusive with `categoryAllowList`. + final List? categoryDenylist; + + /// Converts this pure-Dart representation into C-memory suitable for the + /// MediaPipe SDK to instantiate various classifiers. + Pointer toStruct() { + final struct = calloc(); + _setDisplayNamesLocale(struct.ref); + _setMaxResults(struct.ref); + _setScoreThreshold(struct.ref); + _setAllowlist(struct.ref); + _setDenylist(struct.ref); + return struct; + } + + void _setDisplayNamesLocale(bindings.ClassifierOptions struct) { + if (displayNamesLocale != null) { + struct.display_names_locale = prepareString(displayNamesLocale!); + } + } + + void _setMaxResults(bindings.ClassifierOptions struct) { + // This value must not be zero, and -1 implies no limit. + struct.max_results = maxResults ?? -1; + } + + void _setScoreThreshold(bindings.ClassifierOptions struct) { + if (scoreThreshold != null) { + struct.score_threshold = scoreThreshold!; + } + } + + void _setAllowlist(bindings.ClassifierOptions struct) { + if (categoryAllowlist != null) { + struct.category_allowlist = prepareListOfStrings(categoryAllowlist!); + struct.category_allowlist_count = categoryAllowlist!.length; + } + } + + void _setDenylist(bindings.ClassifierOptions struct) { + if (categoryDenylist != null) { + struct.category_denylist = prepareListOfStrings(categoryDenylist!); + struct.category_denylist_count = categoryDenylist!.length; + } + } + + /// Releases all C memory held by this [bindings.ClassifierOptions] struct. + static void freeStruct(bindings.ClassifierOptions struct) { + if (struct.display_names_locale.address != 0) { + calloc.free(struct.display_names_locale); + } + if (struct.category_allowlist.address != 0) { + calloc.free(struct.category_allowlist); + } + if (struct.category_denylist.address != 0) { + calloc.free(struct.category_denylist); + } + } + + @override + List get props => [ + displayNamesLocale, + maxResults, + scoreThreshold, + ...(categoryAllowlist ?? []), + ...(categoryDenylist ?? []), + ]; +} diff --git a/packages/mediapipe-core/lib/src/third_party/mediapipe/generated/mediapipe_common_bindings.dart b/packages/mediapipe-core/lib/src/third_party/mediapipe/generated/mediapipe_common_bindings.dart new file mode 100644 index 0000000..13bf3d2 --- /dev/null +++ b/packages/mediapipe-core/lib/src/third_party/mediapipe/generated/mediapipe_common_bindings.dart @@ -0,0 +1,347 @@ +/* Copyright 2023 The MediaPipe Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +==============================================================================*/ + +// AUTO GENERATED FILE, DO NOT EDIT. +// +// Generated by `package:ffigen`. +// ignore_for_file: type=lint +import 'dart:ffi' as ffi; + +final class BaseOptions extends ffi.Struct { + external ffi.Pointer model_asset_buffer; + + external ffi.Pointer model_asset_path; +} + +final class __mbstate_t extends ffi.Union { + @ffi.Array.multi([128]) + external ffi.Array __mbstate8; + + @ffi.LongLong() + external int _mbstateL; +} + +final class __darwin_pthread_handler_rec extends ffi.Struct { + external ffi + .Pointer)>> + __routine; + + external ffi.Pointer __arg; + + external ffi.Pointer<__darwin_pthread_handler_rec> __next; +} + +final class _opaque_pthread_attr_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([56]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_cond_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([40]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_condattr_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([8]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_mutex_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([56]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_mutexattr_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([8]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_once_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([8]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_rwlock_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([192]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_rwlockattr_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + @ffi.Array.multi([16]) + external ffi.Array __opaque; +} + +final class _opaque_pthread_t extends ffi.Struct { + @ffi.Long() + external int __sig; + + external ffi.Pointer<__darwin_pthread_handler_rec> __cleanup_stack; + + @ffi.Array.multi([8176]) + external ffi.Array __opaque; +} + +final class ClassifierOptions extends ffi.Struct { + external ffi.Pointer display_names_locale; + + @ffi.Int() + external int max_results; + + @ffi.Float() + external double score_threshold; + + external ffi.Pointer> category_allowlist; + + @ffi.Uint32() + external int category_allowlist_count; + + external ffi.Pointer> category_denylist; + + @ffi.Uint32() + external int category_denylist_count; +} + +final class Category extends ffi.Struct { + @ffi.Int() + external int index; + + @ffi.Float() + external double score; + + external ffi.Pointer category_name; + + external ffi.Pointer display_name; +} + +final class Classifications extends ffi.Struct { + external ffi.Pointer categories; + + @ffi.Uint32() + external int categories_count; + + @ffi.Int() + external int head_index; + + external ffi.Pointer head_name; +} + +final class ClassificationResult extends ffi.Struct { + external ffi.Pointer classifications; + + @ffi.Uint32() + external int classifications_count; + + @ffi.Int64() + external int timestamp_ms; + + @ffi.Bool() + external bool has_timestamp_ms; +} + +const int __WORDSIZE = 64; + +const int __DARWIN_ONLY_64_BIT_INO_T = 1; + +const int __DARWIN_ONLY_UNIX_CONFORMANCE = 1; + +const int __DARWIN_ONLY_VERS_1050 = 1; + +const int __DARWIN_UNIX03 = 1; + +const int __DARWIN_64_BIT_INO_T = 1; + +const int __DARWIN_VERS_1050 = 1; + +const int __DARWIN_NON_CANCELABLE = 0; + +const String __DARWIN_SUF_EXTSN = '\$DARWIN_EXTSN'; + +const int __DARWIN_C_ANSI = 4096; + +const int __DARWIN_C_FULL = 900000; + +const int __DARWIN_C_LEVEL = 900000; + +const int __STDC_WANT_LIB_EXT1__ = 1; + +const int __DARWIN_NO_LONG_LONG = 0; + +const int _DARWIN_FEATURE_64_BIT_INODE = 1; + +const int _DARWIN_FEATURE_ONLY_64_BIT_INODE = 1; + +const int _DARWIN_FEATURE_ONLY_VERS_1050 = 1; + +const int _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE = 1; + +const int _DARWIN_FEATURE_UNIX_CONFORMANCE = 3; + +const int __has_ptrcheck = 0; + +const int __DARWIN_NULL = 0; + +const int __PTHREAD_SIZE__ = 8176; + +const int __PTHREAD_ATTR_SIZE__ = 56; + +const int __PTHREAD_MUTEXATTR_SIZE__ = 8; + +const int __PTHREAD_MUTEX_SIZE__ = 56; + +const int __PTHREAD_CONDATTR_SIZE__ = 8; + +const int __PTHREAD_COND_SIZE__ = 40; + +const int __PTHREAD_ONCE_SIZE__ = 8; + +const int __PTHREAD_RWLOCK_SIZE__ = 192; + +const int __PTHREAD_RWLOCKATTR_SIZE__ = 16; + +const int USER_ADDR_NULL = 0; + +const int INT8_MAX = 127; + +const int INT16_MAX = 32767; + +const int INT32_MAX = 2147483647; + +const int INT64_MAX = 9223372036854775807; + +const int INT8_MIN = -128; + +const int INT16_MIN = -32768; + +const int INT32_MIN = -2147483648; + +const int INT64_MIN = -9223372036854775808; + +const int UINT8_MAX = 255; + +const int UINT16_MAX = 65535; + +const int UINT32_MAX = 4294967295; + +const int UINT64_MAX = -1; + +const int INT_LEAST8_MIN = -128; + +const int INT_LEAST16_MIN = -32768; + +const int INT_LEAST32_MIN = -2147483648; + +const int INT_LEAST64_MIN = -9223372036854775808; + +const int INT_LEAST8_MAX = 127; + +const int INT_LEAST16_MAX = 32767; + +const int INT_LEAST32_MAX = 2147483647; + +const int INT_LEAST64_MAX = 9223372036854775807; + +const int UINT_LEAST8_MAX = 255; + +const int UINT_LEAST16_MAX = 65535; + +const int UINT_LEAST32_MAX = 4294967295; + +const int UINT_LEAST64_MAX = -1; + +const int INT_FAST8_MIN = -128; + +const int INT_FAST16_MIN = -32768; + +const int INT_FAST32_MIN = -2147483648; + +const int INT_FAST64_MIN = -9223372036854775808; + +const int INT_FAST8_MAX = 127; + +const int INT_FAST16_MAX = 32767; + +const int INT_FAST32_MAX = 2147483647; + +const int INT_FAST64_MAX = 9223372036854775807; + +const int UINT_FAST8_MAX = 255; + +const int UINT_FAST16_MAX = 65535; + +const int UINT_FAST32_MAX = 4294967295; + +const int UINT_FAST64_MAX = -1; + +const int INTPTR_MAX = 9223372036854775807; + +const int INTPTR_MIN = -9223372036854775808; + +const int UINTPTR_MAX = -1; + +const int INTMAX_MAX = 9223372036854775807; + +const int UINTMAX_MAX = -1; + +const int INTMAX_MIN = -9223372036854775808; + +const int PTRDIFF_MIN = -9223372036854775808; + +const int PTRDIFF_MAX = 9223372036854775807; + +const int SIZE_MAX = -1; + +const int RSIZE_MAX = 9223372036854775807; + +const int WCHAR_MAX = 2147483647; + +const int WCHAR_MIN = -2147483648; + +const int WINT_MIN = -2147483648; + +const int WINT_MAX = 2147483647; + +const int SIG_ATOMIC_MIN = -2147483648; + +const int SIG_ATOMIC_MAX = 2147483647; + +const int __bool_true_false_are_defined = 1; + +const int true1 = 1; + +const int false1 = 0; diff --git a/packages/mediapipe-core/pubspec.yaml b/packages/mediapipe-core/pubspec.yaml new file mode 100644 index 0000000..501b789 --- /dev/null +++ b/packages/mediapipe-core/pubspec.yaml @@ -0,0 +1,20 @@ +name: mediapipe_core +description: Shared logic and utilities required by other MediaPipe Task packages. +version: 0.0.1-wip +publish_to: none + +repository: https://github.com/google/flutter-mediapipe +issue_tracker: https://github.com/google/flutter-mediapipe/issues + +environment: + sdk: ^3.1.0-333.0.dev + +# Add regular dependencies here. +dependencies: + equatable: ^2.0.5 + ffi: ^2.1.0 + +dev_dependencies: + ffigen: ^9.0.1 + lints: ^2.0.0 + test: ^1.21.0 diff --git a/packages/mediapipe-core/test/task_options_test.dart b/packages/mediapipe-core/test/task_options_test.dart new file mode 100644 index 0000000..143a9ff --- /dev/null +++ b/packages/mediapipe-core/test/task_options_test.dart @@ -0,0 +1,110 @@ +// Copyright 2014 The Flutter Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +import 'dart:ffi'; +import 'dart:typed_data'; + +import 'package:test/test.dart'; +import 'package:mediapipe_core/mediapipe_core.dart'; + +void main() { + group('BaseOptions constructor should', () { + test('enforce exactly one of modelPath and modelBuffer', () { + expect( + () => BaseOptions( + modelAssetPath: 'abc', + modelAssetBuffer: Uint8List.fromList([1, 2, 3]), + ), + throwsA(TypeMatcher()), + ); + + expect(BaseOptions.new, throwsA(TypeMatcher())); + }); + }); + + group('BaseOptions.toStruct/fromStruct should', () { + test('allocate memory in C for a modelAssetPath', () { + final options = BaseOptions(modelAssetPath: 'abc'); + final struct = options.toStruct(); + expect(toDartString(struct.ref.model_asset_path), 'abc'); + expectNullPtr(struct.ref.model_asset_buffer); + }); + + test('allocate memory in C for a modelAssetBuffer', () { + final options = BaseOptions( + modelAssetBuffer: Uint8List.fromList([1, 2, 3]), + ); + final struct = options.toStruct(); + expect( + toUint8List(struct.ref.model_asset_buffer), + Uint8List.fromList([1, 2, 3]), + ); + expectNullPtr(struct.ref.model_asset_path); + }); + + test('allocate memory in C for a modelAssetBuffer containing 0', () { + final options = BaseOptions( + modelAssetBuffer: Uint8List.fromList([1, 2, 0, 3]), + ); + final struct = options.toStruct(); + expect( + toUint8List(struct.ref.model_asset_buffer), + Uint8List.fromList([1, 2]), + ); + expectNullPtr(struct.ref.model_asset_path); + }); + }); + + group('ClassOptions should', () { + test('allocate memory for empty fields', () { + final options = ClassifierOptions(); + + final struct = options.toStruct(); + + expect(struct.ref.max_results, -1); + expect(struct.ref.score_threshold, 0.0); + expectNullPtr(struct.ref.category_allowlist); + expect(struct.ref.category_allowlist_count, 0); + expectNullPtr(struct.ref.category_denylist); + expect(struct.ref.category_denylist_count, 0); + expectNullPtr(struct.ref.display_names_locale); + }); + + test('allocate memory for full fields', () { + final options = ClassifierOptions( + displayNamesLocale: 'en', + maxResults: 5, + scoreThreshold: 0.9, + categoryAllowlist: ['good', 'great', 'best'], + categoryDenylist: ['bad', 'terrible', 'worst', 'honestly come on'], + ); + + final struct = options.toStruct(); + + expect(toDartString(struct.ref.display_names_locale), 'en'); + expect(struct.ref.max_results, 5); + expect(struct.ref.score_threshold, greaterThan(0.8999)); + expect(struct.ref.score_threshold, lessThan(0.90001)); + expect( + toDartStrings( + struct.ref.category_allowlist, + struct.ref.category_allowlist_count, + ), + ['good', 'great', 'best'], + ); + expect(struct.ref.category_allowlist_count, 3); + + expect( + toDartStrings( + struct.ref.category_denylist, + struct.ref.category_denylist_count, + ), + ['bad', 'terrible', 'worst', 'honestly come on'], + ); + expect(struct.ref.category_denylist_count, 4); + }); + }); +} + +void expectNullPtr(Pointer ptr) => expect(ptr.address, equals(0)); diff --git a/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/category.h b/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/category.h new file mode 100644 index 0000000..b6eede4 --- /dev/null +++ b/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/category.h @@ -0,0 +1,50 @@ +/* Copyright 2023 The MediaPipe Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +==============================================================================*/ + +#ifndef MEDIAPIPE_TASKS_C_COMPONENTS_CONTAINERS_CATEGORY_H_ +#define MEDIAPIPE_TASKS_C_COMPONENTS_CONTAINERS_CATEGORY_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +// Defines a single classification result. +// +// The label maps packed into the TFLite Model Metadata [1] are used to populate +// the 'category_name' and 'display_name' fields. +// +// [1]: https://www.tensorflow.org/lite/convert/metadata +struct Category { + // The index of the category in the classification model output. + int index; + + // The score for this category, e.g. (but not necessarily) a probability in + // [0,1]. + float score; + + // The optional ID for the category, read from the label map packed in the + // TFLite Model Metadata if present. Not necessarily human-readable. + const char* category_name; + + // The optional human-readable name for the category, read from the label map + // packed in the TFLite Model Metadata if present. + const char* display_name; +}; + +#ifdef __cplusplus +} // extern C +#endif + +#endif // MEDIAPIPE_TASKS_C_COMPONENTS_CONTAINERS_CATEGORY_H_ diff --git a/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/classification_result.h b/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/classification_result.h new file mode 100644 index 0000000..07ba44f --- /dev/null +++ b/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/containers/classification_result.h @@ -0,0 +1,70 @@ +/* Copyright 2023 The MediaPipe Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +==============================================================================*/ + +#ifndef MEDIAPIPE_TASKS_C_COMPONENTS_CONTAINERS_CLASSIFICATION_RESULT_H_ +#define MEDIAPIPE_TASKS_C_COMPONENTS_CONTAINERS_CLASSIFICATION_RESULT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Defines classification results for a given classifier head. +struct Classifications { + // The array of predicted categories, usually sorted by descending scores, + // e.g. from high to low probability. + struct Category* categories; + + // The number of elements in the categories array. + uint32_t categories_count; + + // The index of the classifier head (i.e. output tensor) these categories + // refer to. This is useful for multi-head models. + int head_index; + + // The optional name of the classifier head, as provided in the TFLite Model + // Metadata [1] if present. This is useful for multi-head models. + // + // [1]: https://www.tensorflow.org/lite/convert/metadata + const char* head_name; +}; + +// Defines classification results of a model. +struct ClassificationResult { + // The classification results for each head of the model. + struct Classifications* classifications; + // The number of classifications in the classifications array. + uint32_t classifications_count; + + // The optional timestamp (in milliseconds) of the start of the chunk of data + // corresponding to these results. + // + // This is only used for classification on time series (e.g. audio + // classification). In these use cases, the amount of data to process might + // exceed the maximum size that the model can process: to solve this, the + // input data is split into multiple chunks starting at different timestamps. + int64_t timestamp_ms; + + // Specifies whether the timestamp contains a valid value. + bool has_timestamp_ms; +}; + +#ifdef __cplusplus +} // extern C +#endif + +#endif // MEDIAPIPE_TASKS_C_COMPONENTS_CONTAINERS_CLASSIFICATION_RESULT_H_ diff --git a/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/processors/classifier_options.h b/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/processors/classifier_options.h new file mode 100644 index 0000000..1c153bd --- /dev/null +++ b/packages/mediapipe-core/third_party/mediapipe/tasks/c/components/processors/classifier_options.h @@ -0,0 +1,61 @@ +/* Copyright 2023 The MediaPipe Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +==============================================================================*/ + +#ifndef MEDIAPIPE_TASKS_C_COMPONENTS_PROCESSORS_CLASSIFIER_OPTIONS_H_ +#define MEDIAPIPE_TASKS_C_COMPONENTS_PROCESSORS_CLASSIFIER_OPTIONS_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Classifier options for MediaPipe C classification Tasks. +struct ClassifierOptions { + // The locale to use for display names specified through the TFLite Model + // Metadata, if any. Defaults to English. + char* display_names_locale; + + // The maximum number of top-scored classification results to return. If < 0, + // all available results will be returned. If 0, an invalid argument error is + // returned. + int max_results; + + // Score threshold to override the one provided in the model metadata (if + // any). Results below this value are rejected. + float score_threshold; + + // The allowlist of category names. If non-empty, detection results whose + // category name is not in this set will be filtered out. Duplicate or unknown + // category names are ignored. Mutually exclusive with category_denylist. + char** category_allowlist; + + // The number of elements in the category allowlist. + uint32_t category_allowlist_count; + + // The denylist of category names. If non-empty, detection results whose + // category name is in this set will be filtered out. Duplicate or unknown + // category names are ignored. Mutually exclusive with category_allowlist. + + char** category_denylist; + // The number of elements in the category denylist. + uint32_t category_denylist_count; +}; + +#ifdef __cplusplus +} // extern C +#endif + +#endif // MEDIAPIPE_TASKS_C_COMPONENTS_PROCESSORS_CLASSIFIER_OPTIONS_H_ diff --git a/packages/mediapipe-core/third_party/mediapipe/tasks/c/core/base_options.h b/packages/mediapipe-core/third_party/mediapipe/tasks/c/core/base_options.h new file mode 100644 index 0000000..d23b688 --- /dev/null +++ b/packages/mediapipe-core/third_party/mediapipe/tasks/c/core/base_options.h @@ -0,0 +1,36 @@ +/* Copyright 2023 The MediaPipe Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +==============================================================================*/ + +#ifndef MEDIAPIPE_TASKS_C_CORE_BASE_OPTIONS_H_ +#define MEDIAPIPE_TASKS_C_CORE_BASE_OPTIONS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +// Base options for MediaPipe C Tasks. +struct BaseOptions { + // The model asset file contents as a string. + char* model_asset_buffer; + + // The path to the model asset to open and mmap in memory. + char* model_asset_path; +}; + +#ifdef __cplusplus +} // extern C +#endif + +#endif // MEDIAPIPE_TASKS_C_CORE_BASE_OPTIONS_H_ diff --git a/tool/ci_script_shared.sh b/tool/ci_script_shared.sh new file mode 100644 index 0000000..183f71a --- /dev/null +++ b/tool/ci_script_shared.sh @@ -0,0 +1,28 @@ +function ci_package () { + local channel="$1" + + shift + local arr=("$@") + for PACKAGE_NAME in "${arr[@]}" + do + echo "== Testing '${PACKAGE_NAME}' on Flutter's $channel channel ==" + pushd "packages/${PACKAGE_NAME}" + + # Grab packages. + flutter pub get + + # Run the analyzer to find any static analysis issues. + dart analyze --fatal-infos + + # Run the formatter on all the dart files to make sure everything's linted. + dart format --output none --set-exit-if-changed . + + # Run the actual tests. + if [ -d "test" ] + then + flutter test + fi + + popd + done +} diff --git a/tool/mediapipe_ci_script_beta.sh b/tool/mediapipe_ci_script_beta.sh new file mode 100755 index 0000000..5f914f4 --- /dev/null +++ b/tool/mediapipe_ci_script_beta.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +set -e + +DIR="${BASH_SOURCE%/*}" +source "$DIR/ci_script_shared.sh" + +flutter doctor -v + +declare -ar PACKAGE_NAMES=( + "mediapipe-core" +) + +ci_package "beta" "${PACKAGE_NAMES[@]}" + +echo "-- Success --" diff --git a/tool/mediapipe_ci_script_master.sh b/tool/mediapipe_ci_script_master.sh new file mode 100755 index 0000000..48c5d65 --- /dev/null +++ b/tool/mediapipe_ci_script_master.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +set -e + +DIR="${BASH_SOURCE%/*}" +source "$DIR/ci_script_shared.sh" + +flutter doctor -v + +declare -ar PACKAGE_NAMES=( + "mediapipe-core" +) + +ci_package "master" "${PACKAGE_NAMES[@]}" + +echo "-- Success --" diff --git a/tool/mediapipe_ci_script_stable.sh b/tool/mediapipe_ci_script_stable.sh new file mode 100755 index 0000000..153dda2 --- /dev/null +++ b/tool/mediapipe_ci_script_stable.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +set -e + +DIR="${BASH_SOURCE%/*}" +source "$DIR/ci_script_shared.sh" + +flutter doctor -v + +declare -ar PACKAGE_NAMES=( + "mediapipe-core" +) + +ci_package "stable" "${PACKAGE_NAMES[@]}" + +echo "-- Success --" From 7850d3269b15552efbeb8f1916b9e90a7d3ee891 Mon Sep 17 00:00:00 2001 From: Craig Labenz Date: Mon, 13 Nov 2023 14:38:14 -0800 Subject: [PATCH 2/6] Add utility to collect headers from google/mediapipe (#10) * adds cmd to pull header files from google/mediapipe * polish and missing parts from git surgery * More comments and touch ups * Apply suggestions from code review * moves build command into `tool/` directory and renames folder `build_cmd` -> `builder` * complete build_cmd -> builder rename * Update readme * Added licenses * Adds DownloadModelCommand --------- Co-authored-by: Kate Lovett --- .flutter-mediapipe-root | 2 + .../example/assets/libtext_classifier.dylib | Bin 0 -> 38568392 bytes tool/builder/.gitignore | 3 + tool/builder/CHANGELOG.md | 3 + tool/builder/README.md | 20 +++ tool/builder/analysis_options.yaml | 2 + tool/builder/bin/main.dart | 25 +++ tool/builder/lib/download_model.dart | 144 +++++++++++++++ tool/builder/lib/repo_finder.dart | 120 +++++++++++++ tool/builder/lib/sync_headers.dart | 167 ++++++++++++++++++ tool/builder/pubspec.yaml | 21 +++ 11 files changed, 507 insertions(+) create mode 100644 .flutter-mediapipe-root create mode 100755 packages/mediapipe-task-text/example/assets/libtext_classifier.dylib create mode 100644 tool/builder/.gitignore create mode 100644 tool/builder/CHANGELOG.md create mode 100644 tool/builder/README.md create mode 100644 tool/builder/analysis_options.yaml create mode 100644 tool/builder/bin/main.dart create mode 100644 tool/builder/lib/download_model.dart create mode 100644 tool/builder/lib/repo_finder.dart create mode 100644 tool/builder/lib/sync_headers.dart create mode 100644 tool/builder/pubspec.yaml diff --git a/.flutter-mediapipe-root b/.flutter-mediapipe-root new file mode 100644 index 0000000..c4598a0 --- /dev/null +++ b/.flutter-mediapipe-root @@ -0,0 +1,2 @@ +// Used to normalize the paths of commands. +// The contents of this file do not matter. diff --git a/packages/mediapipe-task-text/example/assets/libtext_classifier.dylib b/packages/mediapipe-task-text/example/assets/libtext_classifier.dylib new file mode 100755 index 0000000000000000000000000000000000000000..f0c7b68ad29310be6e1ce0404ab3cc1ef2946160 GIT binary patch literal 38568392 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